Emdb

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds value by detailing the return structure (per-model {score, confidence, signals, raw_response} + combined view), pricing (free default model, BYO key for Anthropic), and the authorization note for `_apiKey`. No contradictions.

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

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

The description is concise (approx. 150 words) and well-structured: it starts with the action and output, then adds parameter details, and ends with usage scenarios. 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?

No output schema is provided, but the description adequately explains the return values (per-model fields and combined view). Combined with comprehensive annotations and schema coverage, the description is complete for an agent to understand tool behavior and invocation.

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

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

Schema description coverage is 100%. The description enriches parameter meaning beyond the schema: explains default model for `models`, clarifies `_apiKey` is required for Anthropic probes, and provides examples for `entity` and `context` parameters to illustrate 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 verb 'probe' and resource 'LLMs', specifying the purpose: to check what AI models know about an entity and score visibility (0-100) per model. It distinguishes itself from sibling tools (e.g., ask_pipeworx, entity_profile) by focusing on AI visibility scoring across multiple models.

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

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

The description provides clear usage context: 'Useful for AI-marketing audits, pre-launch brand checks, competitive monitoring.' It explains the default model and optional API key for Anthropic. However, it does not explicitly state when not to use this tool or mention alternative 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 declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context: it routes questions, fills arguments automatically, returns a structured answer with citation URIs, works on every tier, and makes a single fast call. It does not contradict annotations, but it omits potential failure modes or limitations, so a 4 is appropriate.

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

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

The description is longer than average, but it remains well-structured and front-loaded: the opening imperative, supported domains, trigger phrases, examples, and escalation paths each contribute to correct tool selection. Some promotional details like '5,798 tools across 1517 verified sources' are contextual rather than essential, but they reinforce breadth without bloating the core 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?

With only one required parameter and no output schema, the description covers input style, output format (structured answer with citation URIs), tier behavior, and alternatives for escalated needs. It does not explain how to consume the pipeworx:// URIs or address ambiguous queries, but for a routing tool this is a minor gap—an agent can invoke it successfully with the provided 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 description coverage is 100% and every property is an alias of `question` with its own description, so the schema already provides full parameter semantics. The description's example queries add usage color but no new parameter-level meaning (format, length, constraints). Baseline 3 is correct.

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 directive ('PREFER OVER WEB SEARCH') and precisely names the resource: current/historical data across SEC filings, FDA, FRED/BLS, patents, real estate, news, and more. It further clarifies the mechanism—routing to one of 5,798 tools and returning structured answers with stable pipeworx:// citation URIs—and distinguishes itself from siblings like ask_pipeworx_grounded and deep_research.

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 criteria: trigger phrases like 'what is', 'look up', 'find', 'get the latest', and factual questions about real-world entities or numbers, even when web search could answer. It also gives concrete when-not-to-use guidance, naming ask_pipeworx_grounded for hallucination-resistant single answers and deep_research for broad/multi-part questions, plus 'START HERE... default entry point'.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. Beyond that, the description adds valuable context: candidate routing improvements are only active during live tests, no candidate is currently active (so it matches stable exactly), and it is a full working router rather than a fallback stub. 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?

Four sentences, front-loaded with the identity statement, but wordy: the precise retirement date (2026-07-26), the '5,798 tools' count, and the final 'Falls back to nothing' sentence are partly redundant with the earlier 'identical universal router' and 'full working router' claims. Every sentence carries some information, but it could be tighter.

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 covers the response shape by referencing ask_pipeworx ('same response shape'), communicates the current behavioral state, and clarifies the tool is fully functional. Annotations cover the safety profile and the schema covers all parameters. The main gap is the assumption that the agent knows ask_pipeworx's routing behavior and response format from elsewhere.

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

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

Schema description coverage is 100%, with all six parameters documented including the alias relationship (q, text, input, query, prompt as aliases for question). The description adds no per-parameter meaning beyond 'same arguments' as ask_pipeworx, which is a cross-reference rather than semantic detail. 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?

The description identifies the tool as a 'universal router' sharing the same 5,798 tools, arguments, and response shape as ask_pipeworx, and explicitly frames it as the beta/experimental edge of that router. It differentiates from the sibling ask_pipeworx (stable) via the candidate-improvement mechanism, though it leans on ask_pipeworx being known rather than stating the base routing function from scratch.

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 an explicit usage condition: 'Use it exactly like ask_pipeworx when you want the newest routing; results are compared against the stable router to decide what merges.' This names the alternative (stable ask_pipeworx) and the selection criterion. It doesn't explicitly say when NOT to use it (e.g., prefer the stable router for reliability), but the when-to-use guidance is unambiguous.

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

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

The description discloses refusal behavior with enumerated refusal_reason values, the evidence/verbatim-quote return contract, and the fact that it makes one extra LLM call. These traits go well beyond the annotations (read-only, idempotent) and tell the agent exactly what to expect for grounded answers.

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?

Dense but front-loaded: the first clause states the mode and stakes, then flows from routing to output contract to refusal contract to usage guidance and cost tradeoff. No sentence is filler; the length is justified by the tool's complexity.

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

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

Given no output schema, the description provides the field-level return shape, refusal_reason enum, and success/error split, plus the cost/routing context. It is complete enough for an agent to select and invoke the tool correctly in high-stakes scenarios.

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 every parameter is an alias for 'question' with descriptions, so the schema already carries the semantic burden. The description's focus is on usage rather than parameter behavior, so it adds no extra parameter-level 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 opens by naming the tool as a 'hallucination-resistant answer mode,' then explicitly contrasts it with ask_pipeworx: same routing, but it 'EXTRACTS the answer using ONLY what the tool result contains.' This gives a specific verb, resource, and a clear differentiation from its closest sibling.

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

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

Explicit when-to-use and when-not: use when the answer will be quoted, cited, or acted on and facts must not be invented; prefer ask_pipeworx for casual lookups because of the extra LLM call. It even names the alternative tool and the tradeoff.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds extensive behavioral details: market resolution, classification, fan-out, low-confidence handling, closed markets, wide spreads, resolution-rule risk. No contradictions.

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

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

Description is long and detailed, front-loaded with purpose but includes extensive sections (classifiers, fan-out examples, resolver contract) that could be more concise. Adequately structured but overly verbose for quick agent parsing.

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 (3 params, no output schema), the description is comprehensive: covers inputs, outputs, edge cases, safety, resolution rules, and error states. Leaves minimal gaps for agent understanding.

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

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

Schema coverage is 100%, so baseline is 3. Description adds examples for 'market' but does not elaborate on 'depth' or 'include_raw' beyond schema descriptions. No added semantic value for those parameters.

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

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

The description clearly states the tool's purpose: research a Polymarket bet by pulling Pipeworx data. It specifies inputs (slug, URL, question text) and distinguishes from sibling tools like ask_pipeworx by focusing on a single bet with fan-out research.

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 use cases ('should I bet on X', 'what does the data say about Y') but lacks explicit when-not-to-use or alternative tool suggestions. Clear enough for most contexts.

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

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

Beyond the annotations (readOnly, openWorld, idempotent), the description reveals key behaviors: data sources (SEC EDGAR/XBRL, FAERS), fiscal year handling, sorted results by primary metric, and return format (paired data + 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 thorough and front-loaded with usage examples, but slightly verbose. Every sentence adds value, but it could be tightened without loss of clarity.

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

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

Given the tool's complexity (two entity types, multiple data sources, no output schema), the description is comprehensive. It covers input, behavior, output (paired data + citations), and even addresses edge cases like off-calendar fiscal years.

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

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

Schema coverage is 100%, but the description adds significant meaning: it explains that 'values' can be tickers/CIKs for companies and drug names for drugs, clarifies the min/max constraints, and maps enum options to specific data retrieval behaviors.

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: side-by-side comparison of 2-5 companies or drugs. It uses specific verbs ('Compare', 'rank') and resources (SEC EDGAR/XBRL, FAERS), and distinguishes it from sequential lookups with explicit preference guidance.

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

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

The description provides explicit when-to-use triggers (e.g., 'which is bigger/better/larger', 'rank these companies') and when-not-to-use (sequential single-pack lookups). It explains the two entity types and their specific data sources, leaving no ambiguity about context.

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

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

Annotations already mark readOnly/idempotent/non-destructive, and the description adds substantial behavior beyond that: latency expectations (15-60s, up to ~90s for thorough), auth/plan requirements, and the output contract (verbatim evidence + confidence + source + fetched_at + pipeworx:// citation, with gaps[] never invented and contradictions[] on standard/thorough). Also discloses semantic excerpting so agents know answers deep in long records are found rather than head-truncated.

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, with the most critical operational fact front-loaded ('ACCOUNT REQUIRED — use ask_pipeworx if not signed in'). It is long and run-on with minor internal repetition (contradictions[] mentioned twice; depth hops described in both schema and prose), but nearly every sentence carries a distinct signal for a genuinely complex tool.

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

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

No output schema exists, so the description carries the full return-format burden and meets it: findings packet, per-finding fields, citations, gaps[], contradictions[], and hop field. Auth, latency, exclusions, and depth semantics are all covered — nothing an agent needs to invoke this correctly is missing.

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

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

Schema coverage is 100% and the schema already documents both parameters well, including the quick/standard/thorough enums. The description adds operational meaning to depth — paid status of thorough, timing per level, when the follow-up hops are worth it — that the schema enum lacks, though some depth behavior repeats what the schema already states.

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

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

States a specific verb and resource — 'Grounded multi-source research across Pipeworx's 1517 STRUCTURED data sources' — and hard-excludes open-web search. It differentiates from ask_pipeworx explicitly rather than relying on the title, and describes the decomposition/parallel-routing mechanism that makes this distinct from siblings.

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

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

Gives explicit when-to-use guidance: broad/multi-part structured-data questions ('compare X and Y's regulatory + financial exposure'). Names ask_pipeworx as the alternative in three separate conditions — no account, single lookup, and breaking/colloquial current-news — so an agent can route reliably every time.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds that it returns top-N tools with full schemas and examples, ready to call directly, which is useful beyond annotations.

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

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

Description is clear and front-loaded with purpose and usage. Slightly lengthy but each sentence adds value.

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

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

Given no output schema, description explains return values (names, descriptions, schemas, examples) and eliminates need for second lookup, covering all needed context.

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

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

Schema coverage 100% with clear parameter descriptions. Description adds no significant meaning beyond what schema provides; aliases are redundant.

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 finds tools by describing data or task, lists numerous domains (SEC filings, FDA drugs, etc.), and distinguishes itself as the tool discovery tool among siblings.

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

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

Explicitly instructs 'Call this FIRST when you have many tools available and want to see the option set,' and sets context for browsing/searching/discovering.

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

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

Beyond the readOnly/idempotent annotations, it discloses a multi-source fan-out across SEC, XBRL, USPTO, USAspending, FDA Purple Book, DOL, news, and GLEIF. It also reveals the meaning of sources_used/sources_failed, that an empty section is real 'no data' rather than a bug, and that private companies return resolved:false with an explicit notes line.

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 purpose and examples, but it is one dense, run-on paragraph packed with semicolon-separated parentheticals. It would be easier for an agent to parse with bullets or clear input/output sections, even though nearly every detail is 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?

With no output schema, the description carries the burden of explaining return values, and it does so well: cik, company_name, resolved_from/resolved_to, recent_filings with URIs, fundamentals from the latest 10-K, source success/failure status, and private-company behavior. An agent has enough context to invoke the tool correctly and interpret results.

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

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

Schema coverage is 100%, so the description does not need to compensate for missing parameter documentation. It adds useful examples ('AAPL', '0000320193', 'Moderna'), clarifies that type and value are interchangeable, and notes that names resolve via SEC EDGAR's company-name match.

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 action: building a full cross-source profile of a US public company in one parallel call. It gives abundant concrete invocation examples and clearly distinguishes itself from chaining individual SEC/XBRL/news 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?

It explicitly says 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view,' providing both a clear condition and the alternative to avoid. It also documents acceptable input forms and the private-company edge case, so an agent knows when this tool is appropriate.

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 destructiveHint=true, and description confirms deletion. Adds context about clearing sensitive data. 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 concise sentences that clearly state action, usage context, and related tools. 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?

For a simple tool with one required parameter and no output schema, the description fully covers purpose, usage, and pairing with siblings.

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 parameter 'key' is well-described in schema. Description reinforces but does not add new semantic meaning.

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

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

Description specifies the verb 'Delete', resource 'memory', and parameter 'key'. It also mentions sibling tools 'remember' and 'recall', aiding differentiation.

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

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

Explicitly states when to use: when context is stale, task is done, or to clear sensitive data. Also recommends pairing with 'remember' and 'recall'.

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

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. The description adds value by detailing the fetching behavior, extraction of specific fields, and the standardized markdown output format, which helps the agent understand the tool's operation.

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 compact paragraph that front-loads the primary function and immediately provides actionable context. Every sentence contributes meaning, with 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?

Despite no output schema, the description fully explains the output format ('single text blob ready to drop at site-root/llms.txt') and what is extracted. For a tool with only two parameters, this provides complete guidance for an agent.

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

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

Schema coverage is 100%, but the description adds context: 'e.g., https://example.com or a specific landing page' for url, and 'default 25, max 50' for max_links. This clarifies defaults and usage patterns beyond the schema descriptions.

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

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

The description specifies the verb 'Generate', the resource 'llms.txt file', and the exact process: fetches page, extracts title/description/key links, and emits standard llms.txt markdown. It distinguishes from siblings by focusing on a specific output format and 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 explicitly lists three concrete use cases: getting a client's site indexed, drafting for own project, and auditing a competitor. It provides clear context for when to use, though it doesn't explicitly state when not to use or name alternative tools.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, etc. The description adds value by specifying the returned fields and the trimmed nature, which is 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 concise sentences with no redundancy. The first sentence states the main purpose, the second details the return, and the third provides context about EMDB. Very 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?

For a simple retrieval tool with complete schema and annotations, the description covers everything needed: what it gets, how to specify the ID, and what is returned. No gaps.

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

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

The single parameter 'id' is fully described with format ('EMD-1080') and an example. Schema coverage is 100% and the description reinforces the expected input.

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

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

The description clearly states the tool retrieves a single EMDB entry by ID, listing the exact fields returned. It distinguishes from sibling 'search_maps' which likely handles multi-entry 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 an example ID and notes the tool is 'keyless', implying no auth needed. It doesn't explicitly contrast with siblings but the purpose is unambiguous; a when-not statement would strengthen this.

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

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

Annotations already declare readOnlyHint and destructiveHint. Description adds context about default active-only subscriptions and return fields, which is valuable beyond what annotations provide.

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

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

Two sentences: first defines purpose and return format, second gives usage context. No wasted words.

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

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

For a simple list tool with one optional parameter and comprehensive annotations, the description covers all necessary aspects: output fields, default behavior, and usage hints.

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

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

Schema coverage is 100%, so description doesn't need to add much. The description implies the default behavior (active only) but doesn't elaborate on the include_inactive parameter beyond what schema already documents.

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 'List' and the resource 'the caller's active subscriptions', and specifies the return fields. It distinguishes from siblings like subscribe/unsubscribe.

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

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

Provides explicit guidance on when to use: 'review what you're monitoring before adding more or to find an id to cancel'. Does not mention alternatives or when not to use, but the context is clear.

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

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

Beyond the minimal annotations (readOnlyHint=false), the description discloses rate limiting (5 per identifier per day), the claim_token workflow for anonymous filing, how feedback is processed (daily digests, roadmap impact), and that it's free. This is rich behavioral context not captured elsewhere.

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?

Every sentence earns its place. The description is front-loaded with the tool's purpose, then logically flows to exclusions, token workflow, processing behavior, and rate limits. No filler or redundancy.

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

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

For a tool with 4 parameters, no output schema, and two distinct workflows, the description covers all necessary ground: what to report, how to report, how to retrieve responses, rate limits, and exclusions. It is fully self-contained.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra semantics beyond the schema: it explains the two operational modes (file vs. claim via claim_token), clarifies that claim_token must be passed with no other arguments, and describes typical message length. This pushes it above baseline.

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

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

The description uses a specific verb ('Tell the Pipeworx team') and resource ('something is broken, missing, or needs to exist'), clearly distinguishing it from sibling research/info tools. It also lists concrete feedback categories (bug, feature, data_gap, praise).

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 (bug, feature/data_gap, praise) and when NOT to use ('if the tool came from a different MCP server... file it with that server instead'). It also tells users how to frame feedback (in terms of Pipeworx tools/packs, not end-user prompts).

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 hints. The description adds valuable context: data derivation from CF analytics-engine, no PII, cached 5min-1h, and the granularity (pack, tool, count). This goes beyond what annotations provide.

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

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

The description is concise at three sentences, each serving a clear purpose: main function, use cases, and behavioral details. It is front-loaded with the primary output, no wordiness, and every sentence adds value.

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

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

Given the simple input (1 optional enum) and lack of output schema, the description adequately covers input behavior, data source, and caching. However, the output format (shape of the returned data) is only hinted at ('top tools, top packs, total call volume') but not precisely specified, which would improve completeness.

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 sole parameter 'window' has 100% schema coverage with an enum description. The description adds semantics by explaining the effect of different windows ('hot right now' vs. 'steady-state demand'), which is not captured in the schema alone.

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

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

The description clearly states the verb ('Returns') and resource ('top tools, top packs, and total call volume') and specifies the window parameter. It distinguishes from siblings by focusing on trending data from other agents, but does not explicitly contrast with similar tools like 'discover_tools' or 'search_within'.

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 concrete use cases are enumerated, and the window parameter is explained with guidance on short vs. long windows. However, no mention is made of when not to use the tool or alternatives, which would be helpful given the large number of sibling tools.

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

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

Beyond readOnlyHint and idempotentHint, the description details behaviors: scanning scope, similarity threshold, partition filter, fill check, and the conditions under which trades should not be executed. No contradiction with annotations.

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

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

The description is well-structured with labeled sections and front-loaded purpose. While every sentence adds value, it is verbose and could be tightened slightly without losing clarity.

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

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

Given no output schema, the description fully explains the response format and edge cases (similarity filter, placeholder filter, fill check). Covers all behavioral aspects needed for correct invocation.

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

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

Schema coverage is 100% with basic descriptions. The description adds extensive meaning: examples of event slugs and topic questions, behavioral differences between modes, and the concept of 'trending_scan' when no args are provided.

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

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

The description clearly states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It specifies three modes (no args, event, topic) and distinguishes from sibling tools like polymarket_edges and polymarket_fill_risk.

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

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

Explicit guidelines for when to use each mode, with recommendations (e.g., 'event recommended for a specific market'). Provides when-not-to-trade logic (fill check) and references an alternative tool for custom sizing.

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

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

The description adds extensive behavioral context beyond annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint). It explains caching (1h at KV level), edge calculation details (slippage, Kelly, spread), response structure (by_segment with diagnostics), and Fed bets handling. 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 thorough but verbose, covering many details in a dense paragraph format. While it front-loads the purpose, the extensive enumeration of model families and knobs could be more structured and concise. It earns its place but sacrifices brevity.

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 (9 parameters, no output schema), the description is highly complete. It specifies the output structure (by_segment, diagnostics), edge metrics (edge_pp_net, kelly_fraction), and tradeable-edge knobs. It also explains why certain opportunities are excluded (placeholder-slug filter, Fed bets note). This ensures agents can fully understand the tool's behavior.

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

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

Schema coverage is 100% with clear descriptions for all 9 parameters. The description re-explains some parameter purposes but does not add new semantic details beyond the schema. For example, 'min_kelly' is described similarly in both. Baseline 3 is appropriate as the description adds no extra parameter info.

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

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

The description clearly states the tool's purpose: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It distinguishes itself from siblings like 'polymarket_arbitrage' and 'polymarket_edge_tracker' by detailing three model families (MODEL_DRIVEN, STRUCTURAL_ARBITRAGE, CONCENTRATED_LONGSHOT) and the diagnostics, making its specific value proposition clear.

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

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

The description explicitly targets the use case 'what should I bet on today' and explains the tool's advantage ('agents discover opportunities without paging hundreds of markets'). It also describes the tradeable-edge knobs for filtering. However, it does not explicitly state when not to use this tool or name alternatives, which is a minor gap.

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

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

Annotations indicate read-only, idempotent, non-destructive behavior. The description adds substantial detail: response structure (tracked, expired, snapshot_dates), computation of trend and decay_pp_per_day, snapshot gaps, and limitations. 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 detailed and front-loaded with purpose, but it is somewhat lengthy. It could benefit from bullet points or clearer structure, but every sentence adds value and it is not overly verbose for the complexity.

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

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

Despite no output schema, the description thoroughly explains the response format (tracked[], expired[], snapshot_dates[]), key fields, and limitations. It covers all necessary context for an agent to understand usage and output.

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 'days' and 'window'. The description adds some context (e.g., default 14, max 30 for days; default '1wk' for window) but largely repeats schema information. 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 defines the tool's purpose: providing edge persistence and decay telemetry from daily snapshots. It answers a specific question ('how long has this edge existed and is it shrinking?') and distinguishes itself from sibling tools like polymarket_edges by focusing on time-series analysis.

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

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

The description explains when to use the tool (to assess edge age and decay), contrasts fresh vs. old edges, and notes limitations (60-day snapshot TTL, daily closes). It lacks explicit 'when not to use' or alternative tool references, but the context is clear.

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

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

Annotations already indicate read-only, open-world, idempotent, non-destructive. Description adds rich behavioral context: walks ladder, checks order book depth, returns metrics like slippage, verdict, 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?

Description is dense and well-structured with clear sections for single-market and basket modes. Every sentence provides value, but length is justified by tool complexity. Could be slightly more concise but remains effective.

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

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

Despite no output schema, description comprehensively documents return fields for both modes, including edge cases like thin_legs, forced_directional_risk. Covers behavior, parameters, use cases, and warnings. Fully sufficient for an agent to use correctly.

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

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

Schema coverage is 100%, but description greatly enriches parameter meaning: explains default values, modes, interpretations of size_usd for single vs basket, side auto for basket. Also details return fields per mode, which is essential since no output 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 it performs a realizable-vs-theoretical edge check against live CLOB order-book depth, distinguishing between single-market and basket modes. Explicitly references sibling tools (polymarket_arbitrage, polymarket_edges) and positions itself as a prerequisite check.

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

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

Explicitly says 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. Provides when-not guidance by warning of partial basket fills converting arb into unhedged directional position. Also states requirement for either market or event parameter.

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

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

Annotations already declare readOnly/openWorld/idempotent/non-destructive, and the description adds substantial behavioral disclosure beyond that: token-overlap matching, compatibility codes, unknown-leg exclusion, gross-vs-net fee caveats, temporal_alignment null semantics, and skipped counters. None of this contradicts 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 extremely long and dense, with useful front-loading of purpose and modes. Many sentences are necessary because there is no output schema, but there is redundancy (e.g., 'in EITHER mode' and repeated warnings). It is a thorough spec, but not a concise one.

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

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

For a tool with no output schema and complex return semantics, the description covers response shapes, safety fields, compatibility codes, per-pair flags, skipped pairs, fee treatment, and caveats. There is no significant gap an agent would need to guess about before invoking 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%, so the baseline is 3, but the description adds meaningful mode semantics: topic is a pre-mapped shortcut set, explicit ticker/slug overrides the mapped side, and both modes run the identical matcher. This goes beyond the schema's per-parameter descriptions without being redundant.

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

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

The description identifies a specific resource and operation: cross-venue spread between Kalshi and Polymarket for the same resolving question. It clearly distinguishes the tool's scope ('Cross-venue spread') and enumerates two modes and the response contents, so an agent can tell it apart from sibling Polymarket tools by reading the text.

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

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

The description gives clear context: use topic shortcuts for pre-mapped events or explicit tickers/slugs for custom pairings. It also provides a strong caution, 'pre-mapped ≠ tradeable' and warns that most topics return compatibility_warning today. It does not explicitly name sibling alternatives, so it stops short of a 5.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds valuable context about scoping (to identifier) and pairing, which annotations don't cover.

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

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

The description is three sentences, front-loaded with the primary action, and every sentence adds value. No redundant or wasted words.

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

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

Given the simple tool with one optional parameter and rich annotations, the description covers all necessary aspects: dual behavior, usage context, scoping, and pairing with siblings. No output schema is needed for this straightforward retrieval.

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

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

Schema coverage is 100% with a clear description for the only parameter. The description adds meaning by explaining the dual behavior (retrieve vs list), but the schema already conveys this, so value added is limited.

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

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

The description clearly states the tool retrieves a saved value or lists all keys, with a specific verb ('Retrieve') and resource context. It distinguishes itself from siblings 'remember' and 'forget' by explicitly mentioning them and the dual behavior.

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

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

The description explicitly states when to use ('look up context… without re-deriving') and mentions scoping. It doesn't explicitly list alternatives but pairs with 'remember' and 'forget' in a natural way, providing sufficient guidance.

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

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

Annotations state readOnlyHint=true, indicating no writes, but the description states mark_read:true 'flag returned events read so the next call only shows newer ones,' which is a mutation. This is a direct contradiction.

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

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

The description is about 100 words, front-loads the purpose, and each sentence adds value—purpose, output fields, filtering, mark_read effect, and REST alternative. No fluff.

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

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

Despite the contradiction, the description covers all aspects: return fields, parameter usage, polling suitability, and alternative access. No output schema, but returns are described sufficiently.

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

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

Schema coverage is 100%, but the description adds meaning by explaining filter examples ('sec_8k'), ISO timestamp requirement, and the effect of mark_read on subsequent calls. It enriches the schema descriptions.

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

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

The description starts with 'Pull fired events from your subscription feed,' clearly stating the verb and resource. It specifies what is returned (source, citation_uri, payload) and distinguishes from siblings like list_subscriptions.

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

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

Provides context on filtering (type, since) and mark_read behavior, but does not explicitly compare with other tools or state when not to use it. The sibling list_subscriptions is distinct, so implicit guidance is adequate.

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

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

The description discloses behavioral traits beyond annotations: fans out to multiple sources (SEC EDGAR, GDELT/GNews, USPTO), explains fallback logic, soft-fail for USPTO, and how 'since' parameter works. Annotations already indicate read-only, but description adds rich operational detail.

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

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

The description is a single paragraph but packs many details without unnecessary fluff. It could be slightly more structured (e.g., bullet points for sources), but it is still fairly concise and front-loaded with examples.

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

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

Given the tool's complexity (multiple sources, fallback, no output schema), the description explains return structure (changes grouped by source, total_changes count, citation URIs) and provides a clear alternative. All essential context is covered.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining 'since' accepts relative shorthand (e.g., '7d', '30d') and recommends '30d' or '1m' for typical monitoring. It also clarifies 'value' accepts ticker or CIK. This enriches the schema.

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

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

The description uses specific verbs and resources: 'change feed for a company' and provides example queries like 'What's new with X'. It clearly distinguishes from the sibling tool 'entity_profile', stating to use that instead for static profiles.

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

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

The description explicitly states when to use this tool (dynamic change feed) and when to use the sibling 'entity_profile' (static profile). It also explains fallback behavior between GDELT and GNews, giving clear context for usage.

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

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

Annotations indicate write operation (readOnlyHint=false) and idempotent (idempotentHint=true), non-destructive. Description adds scoping details (by identifier) and persistence semantics (persistent for authenticated users, 24-hour TTL for anonymous), going beyond annotations.

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

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

Description is concise (~80 words) and front-loaded with the main purpose. Every sentence adds meaningful information without redundancy.

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

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

Given the tool's simplicity (2 required parameters, no output schema), the description thoroughly explains usage, persistence, scoping, and companion tools, providing complete context for an agent to use it correctly.

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

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

Schema already provides 100% coverage with descriptions for key and value. Description adds concrete examples (e.g., 'subject_property', 'target_ticker') which help the agent choose appropriate key values, adding marginal 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?

Description explicitly states 'Save data the agent will need to reuse later', using a specific verb (save) and resource (data). It distinguishes from siblings by mentioning 'recall' and 'forget' as companion 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 clear when-to-use guidance: 'when you discover something worth carrying forward' and explicitly suggests alternatives: 'Pair with recall to retrieve later, forget to delete.'

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?

Goes far beyond the annotations by disclosing ambiguity handling ('asserts nothing and returns figi_candidates'), explicit unresolved identifiers, source labeling, graceful degradation when LEI/FIGI enrichment is unavailable, and internal cascading through multiple lookup endpoints. This gives the agent an accurate model of what the call will and will not do.

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

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

The description is long and dense, with many parenthetical asides that make scanning harder. However, nearly every sentence carries useful information, and the opening examples plus 'Use FIRST' provide strong front-loading. It would be improved with bullet formatting, but it is not padded.

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 two entity types, multiple identifier sources, no output schema, and moderately complex return behavior, the description covers inputs, outputs, ambiguity, unresolved identifiers, source provenance, fallback behavior, and example invocations. Nothing an agent needs to call this tool correctly is left undocumented.

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 substantial semantics beyond the schema: accepted identifier formats (ticker, CIK, ISIN, name), the ISIN-to-LEI mapping behavior, concrete examples for both types, and the critical warning about passing only the issuer name rather than trailing security-class words. This is far above the baseline.

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

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

The description names a specific verb ('resolve') and resource ('a user-spoken NAME to canonical/official identifiers'), with concrete NL examples and supported types. It is clearly distinct from sibling tools like entity_profile because it frames output as identifiers other tools require as input.

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 FIRST whenever you have a name but need an ID,' giving a clear when-to-use trigger. It does not name or exclude sibling tools, but the trigger is precise enough to route an agent appropriately in most cases.

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 false. Description adds value by explaining it probes with ai_visibility_check, ranks, and returns specific fields (score, confidence, signal density).

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 main action. Second sentence is a bit long but still clear and efficient.

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

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

No output schema, but description explains return value (ranked list with score, confidence, signal density). Also mentions underlying tool and use case. Adequate for 4-param tool with 1 required.

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 does not add significant meaning beyond schema; mentions 'entities' but schema already describes it well.

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

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

The description clearly states the tool compares AI visibility across multiple entities, probes with ai_visibility_check, ranks by score, and surfaces most/least recognized. It distinguishes itself from sibling like compare_entities by focusing on AI presence.

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

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

Explicitly states use case for competitive AI-marketing audits with an example question. Does not explicitly say when not to use, but context is clear.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable context about partial failures (bundlephobia first measurement takes 5-30s, sources_failed list) and ecosystem limitations, exceeding what annotations provide.

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

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

The description is a single paragraph but efficiently packs essential information without redundancy. It could be slightly more structured, but every sentence contributes value and the key details are front-loaded.

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

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

Given the tool's complexity (composite query, two data sources, partial failures), the description covers all critical aspects: return fields, failure behavior, ecosystem scope, and version defaults. No output schema exists, but the description compensates thoroughly.

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. The description does not add significant new information beyond the schema, meeting the baseline expectation but not exceeding it.

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

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

The description clearly states the tool performs a composite check for npm packages, aggregating data from deps.dev and bundlephobia. It uses specific verbs like 'scan' and 'check', and distinguishes itself from sibling tools by focusing on npm dependency evaluation.

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 tells when to use the tool ('is it safe/popular/small?') and when not to (other ecosystems should use deps.dev directly). It also mentions graceful degradation and timeout behavior, providing clear usage context.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. The description adds that it returns specific fields (EMDB id, title, resolution, method) and is 'keyless'. No additional disclosure needed beyond annotations; description adds 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?

Three sentences, each adding value: purpose, return fields, and comparison to alternatives. No wasted words. Front-loaded with action.

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

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

Given the annotations (readOnlyHint, openWorldHint, etc.) and full schema, the description covers all needed context: what is searched, returned fields, usage examples, and ecosystem fit. No output schema, but return values are described in text.

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

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

Schema coverage is 100%, with both 'query' and 'limit' described. The description adds example keywords and default/max for limit but does not significantly extend schema meaning. 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 specifies 'Search the EBI Electron Microscopy Data Bank (EMDB) for 3D cryo-EM / electron-tomography density maps' with a clear verb and resource. It distinguishes from siblings like 'search_within' (searches within) and 'get_map' (retrieves specific map).

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

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

The description states 'Complements PDB/AlphaFold (which hold atomic/experimental structures)' and gives example keywords ('ribosome', 'spike protein'). It implies when to use this tool (for density maps) versus others. Explicit alternatives are provided.

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

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

The description adds behavioral details beyond annotations: 'BGE-base-en embeddings + cosine over 500-char overlapping windows' and 'cap is 200K chars (longer inputs are truncated and flagged)'. Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint—no contradiction.

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

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

The description is front-loaded with purpose and well-organized. It is slightly wordy in the middle (the second sentence could be trimmed), but every sentence adds value. Still, it is 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 tool's complexity (semantic search, truncation, embeddings), the description is remarkably complete. It explains output format (passages with offsets and scores), technical details (embeddings model, window size, character cap), and use case integration. No output schema exists, but the description covers return values adequately.

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

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

Schema coverage is 100% with descriptions for all 3 parameters. The description adds extra context beyond the schema: examples for 'text' (SEC 10-K body), 'query' (e.g., 'supply-chain risk'), and the default/range for 'limit'. This adds value, justifying a 4.

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

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

The description clearly states 'Semantic search INSIDE a fetched record' with concrete examples (SEC 10-K, article, tool result). It explains what is returned (top-N passages with offsets and scores) and references a sibling tool for pairing, effectively distinguishing its 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?

Explicitly states when to use: 'Use when the record is too big to cram into the prompt' and explains how it saves context. Also provides a pairing recommendation with 'ask_pipeworx_grounded', giving clear guidance on alternatives and integration.

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 states 'Returns the new subscription id,' implying each call creates a new subscription, which contradicts the annotation idempotentHint=true. According to the rules, a contradiction yields a score of 1. The description otherwise provides good behavioral context (delivery channels, rate limits, webhook disablement), but the contradiction is a serious flaw.

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

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

The description is detailed and well-structured, with the main purpose front-loaded. Every sentence adds necessary information (prerequisites, types, delivery channels, limitations). It could be slightly more concise, but it efficiently packs a lot of useful content.

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

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

Given the complexity (3 parameters, nested objects, no output schema), the description is remarkably complete. It covers all supported types, their params, delivery options, return value, and caveats (rate limits, phone verification, webhook auto-disable). No gaps identified.

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

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

Schema coverage is 100%, so baseline is 3. The description adds significant value by providing concrete examples for each type (e.g., 'items:["5.02"] = officer change') and explaining the params object in detail, which goes beyond the schema descriptions.

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

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

The description clearly states the tool's action: 'Create a proactive monitoring subscription to a live-data event stream. Returns the new subscription id.' This distinguishes it from sibling tools like list_subscriptions (list), unsubscribe (delete), and recent_alerts (pull). The verb 'Create' and resource 'subscription' are specific.

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

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

The description provides clear context for when to use the tool (to set up proactive monitoring alerts) and mentions limitations ('anonymous + BYO cannot persist subscriptions'). However, it does not explicitly contrast with alternatives like list_subscriptions or recent_alerts, though the purpose is sufficiently clear.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds value by explaining the return format (category-bucketed examples with tool shapes) and that it uses a live catalog, providing behavioral context beyond the annotations.

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

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

The description is two sentences but densely packed with synonyms, output description, usage instructions, and when-to-use. It is front-loaded with common phrasings. Slightly long but justified by the information density.

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

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

Given no output schema, the description thoroughly explains the return value (category-bucketed examples with tool+argument shapes). Covers main use case, parameter behavior, and usage context. Complete for a simple one-parameter tool.

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

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

Schema coverage is 100% with one optional parameter 'topic'. The description repeats the enum values and clarifies that omitting gives cross-category spread while providing a topic focuses results. This adds practical usage context beyond the schema description.

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

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

The description explicitly states the tool returns category-bucketed example questions with tool+argument shapes, serving as an onboarding entry point. It distinguishes itself from sibling tools like ask_pipeworx and compare_entities by being a meta-tool for exploring capabilities.

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

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

Provides clear when-to-use guidance: 'Use this FIRST when you do not yet know what Pipeworx can do for you'. Also specifies optional narrowing by topic and mentions learning to call meta-tools, effectively differentiating usage contexts.

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=false, destructiveHint=false, and idempotentHint=true. The description adds valuable behavioral context: ownership enforcement (can only cancel own subscriptions) and that the row is deactivated (not deleted) so historical events remain available. This clarifies the exact side effects beyond what annotations provide.

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

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

The description is concise: three sentences that are front-loaded with the core action ('Cancel a subscription by id'), followed by essential behavioral details. Every sentence adds value without redundancy.

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

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

Given the tool has only one parameter, no output schema, and annotations cover safety and idempotency, the description is sufficiently complete. It explains the effect (deactivation not deletion), ownership, and the relationship to 'recent_alerts'. No further information is needed for an agent to use this tool correctly.

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

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

The input schema has 100% coverage with a description for the 'id' parameter: 'Subscription id (uuid) returned by subscribe.' The tool description does not add any additional parameter details beyond the schema, so the baseline score of 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?

The description clearly states 'Cancel a subscription by id', specifying the verb and resource. It distinguishes from siblings like 'subscribe' and 'list_subscriptions' by noting ownership enforcement and that the row is deactivated, not deleted, keeping historical events available via 'recent_alerts'.

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

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

The description indicates when to use the tool (to cancel a subscription) and provides context such as ownership enforcement and that the action is a deactivation, not deletion. It does not explicitly state when not to use it or compare to alternatives like permanent deletion, but the sibling context and behavior hints are sufficient.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description adds significant context: verdict enumeration, fast-path vs grounded pipeline, citation format, and critical error semantics distinguishing could_not_verify (check did not happen) from unsupported (no source). This is beyond the annotations and highly valuable.

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: trigger phrases first, then usage, routing, output, and edge cases. Every sentence contributes, but it is dense and could be slightly tightened without losing meaning. Front-loaded effectively.

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

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

Given no output schema, the description compensates by enumerating verdict values, explaining return content (value + citation), and clarifying error vs unsupported. It also covers routing logic and the efficiency benefit. This is 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?

Schema covers both parameters (claim, tolerance_pct) at 100%, so baseline is 3. The description adds valuable semantics for tolerance_pct: how it overrides implied tolerance, range, and typical use for hallucination detection. This extra guidance justifies a 4.

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

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

Description clearly states the tool does natural-language claim verification with specific verbs like 'fact check' and 'verify the claim', and distinguishes itself by covering both structured SEC EDGAR and grounded pipelines in one call, replacing multiple sequential steps. It is well differentiated from sibling tools.

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

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

Provides explicit when-to-use: 'Use whenever the agent needs to check whether something a user said is factually correct' and explains routing for company-financial vs other claims. However, it does not explicitly name alternatives or state when not to use it; the absence of exclusions puts it just below a 5.

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