South Africa Tenders

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, which the description confirms by describing the probe as non-destructive. The description adds value by noting the default model is free and Anthropic requires a BYO key, with cost implications. No contradictions.

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

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

The description is a single paragraph of four sentences, front-loading the purpose and then providing key details. Every sentence adds value with no redundancy.

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

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

Given no output schema, the description adequately explains return structure (per-model {score, confidence, signals, raw_response} + combined view). It covers the main parameters and usage scenarios, though more detail on scoring might be helpful but not necessary.

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%, but the description adds meaning beyond schema: it explains the default model for 'models', clarifies that '_apiKey' is only needed for 'anthropic', and describes 'context' as disambiguation. This enhances usability.

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

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

The description clearly states the tool probes LLMs for knowledge and scores visibility (0-100) per model, with a specific verb ('probe') and resource ('LLMs for what they know about a business/brand/product/topic'). It distinguishes from siblings by its unique focus on AI visibility scoring, different from other tools like 'scan_competitor_ai_presence'.

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

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

The description explicitly says 'Useful for AI-marketing audits, pre-launch brand checks, competitive monitoring,' providing clear context. It does not mention when not to use or compare with direct alternatives, but the sibling list exists for reference.

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

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

Annotations already establish safety (readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false), and the description builds on this by disclosing routing behavior across 5,908 tools, automatic argument filling, and stable pipeworx:// citation URIs. This adds meaningful behavioral context beyond the annotations. It could go further by noting any limits on hallucination, latency, or unavailable sources, but it does not contradict the annotations.

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

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

The description is front-loaded with the most important directive, 'PREFER OVER WEB SEARCH', followed by the tool's scope and examples. It is longer than necessary, with some redundancy in the topical list and the phrase 'anything requiring authoritative structured data with citations', but every major section earns its place by supplying selection and usage 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?

For a routing tool with a single natural-language input and no output schema, the description is unusually complete: it states what the tool does, when to use it, how it behaves, and what it returns (structured answer with citation URIs). It even gives enough domain examples to calibrate the agent's expectations. The annotation set covers safety and the description covers behavior and return format, leaving no critical gap for 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?

The input schema covers 100% of the 6 parameters, and five of them are explicitly documented as aliases for the single required 'question' parameter. The description reinforces natural-language usage with examples but adds no new parameter-level semantics beyond what the schema already provides. This matches the baseline for full schema coverage.

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

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

The description states a precise purpose: route natural-language factual questions to one of thousands of verified source-backed tools and return a cited structured answer. It clearly distinguishes the tool from generic web search by listing domains and giving concrete examples. The scope is immediately understandable and specific enough for an agent to know whether this tool applies.

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?

Usage guidance is explicit and actionable: 'PREFER OVER WEB SEARCH' signals when to select this tool over the obvious alternative, and 'START HERE for most questions' reinforces priority. It enumerates query formulations ('what is', 'look up', 'find', 'get the latest') and supplies representative examples. The instruction to use it even when web search could also answer removes ambiguity about selection.

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

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

Annotations already indicate read-only, open-world, idempotent, and non-destructive behavior. The description adds valuable context beyond annotations: candidate routing improvements are enabled live only when under test, no candidate is active as of a specific date, and this is a full working router with no degraded fallback. This transparency helps an agent understand the experimental edge without overestimating risk.

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

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

The description is front-loaded with the tool's identity as the beta variant and stays information-dense. There is some redundancy between 'identical', 'currently matches ask_pipeworx exactly', and 'use it exactly like ask_pipeworx', but each repetition adds emphasis rather than confusion.

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 rich annotations, high schema coverage, and the explicit statement that the response shape matches ask_pipeworx, the description gives an agent enough context to call the tool correctly. The lack of an output schema is mitigated by the reference to ask_pipeworx's identical response shape. It does not document every edge behavior, but it is sufficiently complete for a router-style tool.

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

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

Schema description coverage is 100%, with the 'question' parameter fully described and all aliases documented in the schema. The description adds only that the tool accepts 'the same arguments' as ask_pipeworx, which does not materially enhance parameter understanding. Baseline 3 is appropriate because the schema carries the explanation burden.

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 this is the beta version of ask_pipeworx, an identical universal router with the same toolset, arguments, and response shape. It distinguishes itself from the stable sibling ask_pipeworx by emphasizing experimental routing improvements, so an agent can differentiate it without opening schemas.

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

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

The description explicitly says to use it exactly like ask_pipeworx when the newest routing is desired, and clarifies that results are compared against the stable router. It implies the stable version exists for production-stable use, but does not explicitly state when not to use this tool versus ask_pipeworx_grounded or other alternatives.

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

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

Beyond the readOnly/openWorld/idempotent annotations, the description discloses important behavioral details: answer extraction is restricted to tool results, refusal reasons are explicitly enumerated, and an additional LLM call is incurred. This significantly exceeds the annotation coverage.

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 carries distinct value: behavior, output shape, refusal semantics, usage guidance, and cost tradeoff. Dense but well-organized, with key guidance 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 annotations and full schema coverage, the description fully explains return values, refusal modes, and when to choose this tool over the sibling. No critical operational detail is missing.

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

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

Schema description coverage is 100%, so the schema already documents parameters. The description doesn't add parameter-level detail but does clarify the output and refusal structure, which indirectly helps agents interpret results. 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 names a specific mode ('hallucination-resistant answer mode'), ties it to a resource (Pipeworx), and explicitly contrasts it with ask_pipeworx. It clearly identifies what the tool does and distinguishes it 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?

The description gives explicit usage guidance: use when answers will be quoted, cited, or acted on, and when fact invention is unacceptable; prefer ask_pipeworx for casual lookups. It also notes the extra LLM call cost, helping the agent choose correctly.

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, open-world, idempotent, non-destructive behavior. The description adds extensive behavioral context: response shapes (market, analysis, evidence), resolver contract (match confidence, alternatives), parent event extractor, news fields, safety short-circuits (low-confidence, closed markets), wide-spread handling, and resolution-rule risk. All details are consistent with annotations and go far beyond them.

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

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

The description is front-loaded with the main purpose and structured logically through sections (input, process, response shapes, resolver, etc.). While it is lengthy, every sentence adds value given the tool's complexity. It could be slightly more concise, but the organization aids readability.

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

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

The description covers all aspects of the tool with no output schema: input resolution, classification categories, fan-out examples per category, response structure, safety mechanisms, edge cases (closed markets, wide spreads, resolution rules). It is exceptionally complete for a complex tool, leaving no major gaps for an agent to understand 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 descriptions for all three parameters. The description adds significant meaning: explaining the 'depth' enum values (quick vs thorough), elaborating on the 'market' parameter input formats, and detailing when to use 'include_raw' (false for compact responses, true for full payloads). This provides context beyond the schema itself.

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 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the input formats (slug, URL, question text), the process (resolve, classify, fan-out), and output (evidence packet + comparison). The tool is distinct from siblings, which cover different functionalities like arbitrage or edge tracking.

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

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

The description provides explicit use cases: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It also gives examples of category-specific fan-outs, guiding the agent on when to use this tool for research. However, it does not mention alternatives or when not to use it, which would improve clarity.

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

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

Annotations declare readOnly, openWorld, idempotent. Description adds context: handles off-calendar fiscal years, sorts by primary metric, returns citation URIs. No contradictions. However, does not mention any potential rate limits or error handling.

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

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

Well-structured with actionable examples first, then details. Slightly long but each sentence adds value. Could be trimmed slightly but 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?

Covers all essential aspects: entity types, count limits, data sources, sorting, and output format (paired data + URIs). No output schema exists, but description compensates well.

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 enriches meaning by explaining enum values (company vs drug) with data sources, and provides examples for the values array. Goes beyond schema.

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

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

Description clearly states the tool performs side-by-side comparison of 2-5 companies or drugs in one parallel call, with specific verb (compare) and resource (entities). Distinguishes from siblings like entity_profile by replacing sequential lookups.

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

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

Explicitly says 'ALWAYS PREFER over sequential single-pack lookups when comparing entities' and provides trigger examples like 'compare X and Y'. Clearly indicates use case and preference over alternatives.

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

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

Beyond the readOnly/idempotent annotations, the description discloses account requirements, output packet structure (verbatim evidence, confidence, source, fetched_at, pipeworx:// citations), explicit gaps[], 'never invented' behavior, contradictions[] on standard/thorough, semantic excerpting, and latency expectations. This is rich, non-contradictory behavioral 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 dense and front-loaded with critical access information and the key differentiation from ask_pipeworx. There is minor redundancy with schema depth descriptions, but overall each sentence earns its place and the structure flows from usage constraints to behavior to timing.

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

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

For a complex research tool with no output schema, the description covers inputs, expected latency, return packet contents, gap behavior, citation stability, contradictions, and account constraints. It is sufficiently complete for an agent to understand what will happen and what it will receive.

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 meaning beyond the schema by explaining depth tiers in practical terms (quick=3 single hop, standard=3 default, thorough=6 paid), reiterating that question can be multi-part natural language, and tying depth choices to paid-plan constraints. This goes beyond the schema's field 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 states a specific verb and resource: 'Grounded multi-source research across Pipeworx's 1540 STRUCTURED data sources ... in ONE call' and explains the internal mechanism of decomposition and parallel routing. It explicitly distinguishes itself from open-web search and from ask_pipeworx, so an agent can clearly differentiate it from sibling tools.

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

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

It gives explicit when-to-use guidance: 'Best for broad/multi-part questions over structured data' with concrete examples. It also provides exclusions and alternatives: 'If you are not signed in, use ask_pipeworx instead' and 'For a single lookup use ask_pipeworx instead.' This fully routes the agent between deep_research and ask_pipeworx.

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

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

Annotations already mark it as read-only and idempotent; the description adds that results include full schemas with examples and are ready to call directly, but doesn't mention rate limits or auth.

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

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

Front-loaded with the main action and is concise, though slightly verbose; 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?

No output schema, but the description explains the return value (top-N tools with schemas). Adequate for a discovery tool with moderate complexity.

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

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

Schema coverage is 100% with descriptions; the description adds that multiple aliases (task, q, search, description) are accepted and gives examples, adding meaning beyond the schema.

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

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

The description uses specific verb 'Find tools by describing the data or task' and lists many domains (SEC filings, FDA drugs, etc.), distinguishing itself from sibling tools that do specific tasks.

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 'Call this FIRST when you have many tools available' and provides use cases, but lacks explicit when-not to use.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive, but the description adds substantial behavioral context beyond that: it fans out across multiple sources in parallel, soft-fails on USPTO's sunset, returns real 'no data' rather than errors, and reports which sources succeeded/failed. It even notes that empty fda_products is expected for non-biologic companies, which prevents misinterpretation.

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

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

The description is long but every section earns its place given the tool's many data sources and the absence of an output schema. It is front-loaded with usage examples and the decisive preference rule before enumerating return fields. Minor redundancy exists between the opening 'ONE parallel call' emphasis and the later 'ALWAYS PREFER' line, but overall structure is logical.

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

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

Given the tool has no output schema and touches many heterogeneous sources, the description is remarkably complete: it covers accepted inputs, output fields, source-specific quirks, failure modes, and expected empty results. An agent has enough information to invoke it correctly and interpret any response.

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

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

Schema coverage is 100%, but the description enriches both parameters considerably: it gives concrete accepted examples, explains zero-padded CIK format, states that the two type enum values behave identically, and clarifies that names are resolved via SEC EDGAR. This goes well beyond the schema's terse field 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 opens with concrete user phrasings and then states the core function: "full cross-source profile of a US public company in ONE parallel call." It clearly differentiates itself from single-lookup chaining and lists the exact data domains returned, so an agent can tell it apart from siblings like resolve_entity or compare_entities without probing the schema.

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," giving a direct routing rule. It also covers input variants (ticker, CIK, name), the interchangeable type values, and the expected result for private companies, so an agent knows when this tool will and won't satisfy the request.

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

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

Annotations already indicate destructiveHint=true and idempotentHint=true, so the destructive nature is known. Description adds context about clearing sensitive data but does not reveal new behavioral traits 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?

Three sentences, each adding value: main action, when to use, and related tools. No redundancy, well front-loaded.

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

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

For a simple tool with one parameter, no output schema, and annotations covering safety, the description is complete. It also mentions pairing with sibling tools, providing enough context for correct usage.

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

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

Schema coverage is 100% and the parameter 'key' already has a description 'Memory key to delete'. The description mentions 'by key' but adds no additional semantics beyond the schema.

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

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

Description clearly states specific verb 'Delete' and resource 'previously stored memory by key'. It distinguishes from sibling tools by mentioning 'remember and recall', making the purpose unambiguous.

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

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

Provides explicit use cases: stale context, task done, clear sensitive data. Suggests pairing with remember and recall. Does not explicitly state when not to use, but guidance is clear enough.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, non-destructive. The description adds that it fetches the page, extracts title/description/key links, and outputs a single text blob. This is sufficient beyond annotations.

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

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

The description is concise, front-loaded with purpose, and every sentence adds value. No redundant information.

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

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

With 2 parameters, annotations, and no output schema, the description fully explains what the tool does, how it works, and what the output looks like. Use cases are provided.

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 adds minimal extra detail (e.g., default and max for max_links), so score of 3 is appropriate.

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

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

The description clearly states the tool generates an llms.txt file for any URL, with specific verb 'Generate' and resource 'llms.txt file'. It distinguishes from siblings like scan_competitor_ai_presence by focusing on creation of the standard file.

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

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

The description provides explicit use cases: indexing a client's site, drafting for own project, auditing competitor. It does not explicitly mention when not to use or direct alternatives, 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 safe, read-only behavior. The description adds that it returns active subscriptions by default, with optional include_inactive, and lists return fields. No contradictions.

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

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

Three sentences: what, returns, when to use. No redundant words, front-loaded with core 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?

Adequate for a simple list tool with one optional parameter. Could mention pagination but not critical. Complete enough given annotations and schema.

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

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

Schema coverage is 100% with one boolean parameter. The description adds that default is active only, but this is implied by the parameter name. Baseline 3 is appropriate as description adds marginal value.

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

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

The description clearly states it lists the caller's active subscriptions, with specific fields returned. It distinguishes from siblings like 'subscribe' and 'unsubscribe'.

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

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

The description provides explicit use cases: review before adding more or find an id to cancel. It does not mention 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?

Annotations are all false, leaving the description to carry the burden. It richly discloses behavior: anonymous filing returns a `claim_token` that can be used later to check resolution status, rate-limit is '5 per identifier per day', the tool is free and 'doesn't count against your tool-call quota', and the team processes digests daily. This far exceeds annotation coverage.

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 dense; every sentence adds behavioral or usage information. Minor redundancy exists in the enumerated feedback types (also mirrored in the schema's enum), and the roadmap signal note is motivational rather than operational. Still, overall structure is logical and front-loaded with purpose.

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

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

Given the tool's moderate complexity, no output schema, and all-false annotations, the description is complete. It covers what the tool does, when to use it, what inputs mean, the anonymous claim_token workflow, rate limits, and exclusions. Nothing essential is missing for an agent to invoke 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 coverage is 100%, so baseline is 3. The description adds valuable semantics beyond the schema: it clarifies how to phrase `message` ('Describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt') and how `claim_token` should be passed later to read the reply. This lifts 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 opens with a specific verb and resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly distinguishes the tool from siblings by restricting scope to 'tools served by this Pipeworx connection' and enumerating exact feedback types (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?

The description gives explicit when-to-use guidance across four categories and explicit when-not-to-use guidance: 'if the tool came from a different MCP server... we cannot fix it and reporting it here only delays you; file it with that server instead.' It also provides a disambiguation heuristic: 'Pipeworx tool names are the ones this connection lists.'

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable context: data is derived from CF analytics-engine, no PII, cached 5min-1h depending on window, and self-aggregating signal. This goes beyond annotations but could still mention rate limits or pagination. 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 concise (about 6 sentences), well-structured with front-loaded core function and bulleted use cases. Every sentence adds value without redundancy or unnecessary detail.

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 optional parameter and no output schema, the description is complete. It covers data source, privacy, caching, and use cases. Annotations further enrich the context. 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% with a clear enum description for the only parameter 'window'. The description adds meaning beyond the schema by explaining the trade-off: shorter windows surface current hotness, longer windows show steady-state demand. This helps the agent choose appropriately.

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

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

The description clearly states the tool returns 'top tools, top packs, and total call volume' over a window, using specific verbs like 'Returns' and 'calling'. It distinguishes from siblings by focusing on trending/aggregate data, which is unique among a large set of sibling tools.

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

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

The description explicitly lists three distinct use cases (discovering hot data sources, confirming canonical choice, aligning with needs). It also provides context on caching and privacy. However, it does not explicitly state when not to use this tool or mention alternatives, which prevents a perfect score.

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

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

Description adds substantial behavioral context beyond annotations: explains monotonicity checks, partition-sum verification, fill check against live order book, semantic anchor for cross-event pairs, and partition filter logic. No contradiction with annotations (all hints are consistent).

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 lengthy but well-organized with clear sections. It front-loads the main purpose and usage. Some technical details (SEMANTIC ANCHOR, PARTITION FILTER) could be slightly trimmed, but overall structure is effective for the complexity.

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

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

Given no output schema, the description thoroughly covers expected response structure and behavior. It explains all modes, return fields, and caveats. Minor gap: does not explicitly state error handling or behavior when no arbitrage is found, but that is implicit.

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

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

With 100% schema coverage, baseline is 3, but description greatly enhances meaning: provides concrete examples for event slugs and topic seeds, explains how each mode works, and describes response fields. This goes well 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 finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes between three modes (trending scan, event, topic) and differentiates from sibling tools like polymarket_fill_risk by noting it directs custom sizing to that tool.

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

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

Explicit guidance on when to use each parameter: no args for trending scan, event for specific market (recommended), topic for cross-event scanning. Also warns against trading when realizable edge is non-positive and references a sibling tool for custom sizing, providing clear when-not-to-use instructions.

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 extensive details: three model families with specific logic, caching at KV level keyed on knobs, placeholder filters, Fed bets excluded from ranking, and diagnostics for segment emptiness. No contradiction with annotations.

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

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

The description is long but well-structured: starts with purpose, then breaks down segments and response structure, then covers knobs and caching. Front-loaded with essential info. Every sentence adds value, though could be slightly more concise.

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

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

Given the tool's complexity (9 parameters, 3 model families, no output schema), the description is exceptionally complete. It explains output segments, diagnostics for why empty, caching, and Fed note — leaving no gaps for an agent to understand behavior and response.

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

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

Schema coverage is 100% with all 9 parameters documented. The description adds context on how tradeable-edge knobs work (e.g., min_liquidity drops thin-book opportunities) and explains the role of min_partition_leg_kelly, enhancing understanding beyond schema.

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

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

The description clearly states the tool scans Polymarket markets to find opportunities where Pipeworx data disagrees with market price, targeting the 'what should I bet on today' use case. It distinguishes itself from siblings like polymarket_arbitrage by focusing on edge opportunities from disagreement.

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 frames the tool for discovering betting opportunities without paging hundreds of markets. While it doesn't list alternatives or when-not-to-use, the use case is clearly defined.

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

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

Annotations already indicate readOnly, idempotent, and non-destructive behavior. The description significantly adds behavioral context: data source (daily snapshots), response structure (tracked, expired, snapshot_dates), meaning of fields (trend, decay_pp_per_day), and limitations (60-day TTL, daily closes, not intraday). 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 fairly long but well-structured, with each section serving a purpose: introduction, parameters, response format, and limitations. It is front-loaded with the key question. Could be slightly more concise, but the density of information justifies the length.

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

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

Given the tool's complexity and lack of output schema, the description is remarkably complete. It covers all essential aspects: what the tool returns (three arrays with field explanations), edge cases (snapshot gaps), and limitations (60-day TTL, data freshness). No major gaps.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds meaning by clarifying that 'days' is a lookback with default 14 and max 30 (matching schema), and 'window' is a snapshot family with default '1wk', which aligns with schema. It provides additional context on parameter roles but does not introduce new information beyond schema.

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

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

The description clearly states the tool's purpose: tracking edge persistence and decay over time. It provides a concrete analogy ('fresh wide edge vs 3-week-old edge') and distinguishes from sibling tools like polymarket_edges by focusing on temporal 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 gives clear context on when to use the tool (to assess edge longevity and shrinkage). While it doesn't explicitly name alternatives, the contrast with 'fresh wide edge' implies when it's appropriate, and the sibling list provides alternatives for different questions.

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

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

Annotations already mark it as read-only, open-world, idempotent, non-destructive. Description adds context: walks the ladder, returns specific fields (top_of_book, slippage_pp, shares_filled, verdict etc.), and warns about the risk of partial basket fills creating directional exposure. No contradiction with annotations.

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

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

The description is lengthy but well-structured with explicit sections for SINGLE-MARKET and BASKET, using bold and clear field lists. Every sentence adds value, but some details (e.g., exact return fields) could be shorter if an output schema existed. Still earns a 4 for being informative 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 complexity (4 params, no output schema), the description fully covers both modes, defaults, return values, and usage context. It also includes risk warnings and contextualizes the tool within the arb bot workflow. Nothing essential is missing.

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

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

Schema description coverage is 100% (baseline 3). Description adds meaning: explains side default in basket mode (auto based on partition sum), clarifies size_usd interpretation for buys vs sells and basket notional. Also explains the one-of requirement for market/event and their modes.

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 checks realizable vs theoretical edge against order-book depth. Distinguishes between single-market and basket modes, and explicitly positions it as a prerequisite step for arb signals. Differentiates from sibling tools like polymarket_arbitrage and polymarket_edges.

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

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

Explicitly states when to use: 'USE THIS before acting on any polymarket_arbitrage... or any polymarket_edges trade above ~$500.' Explains why partial basket fills convert arb to unhedged directional. Specifies required parameter (market or event one-of) and defaults for side and size_usd.

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

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

Annotations provide only readOnly/openWorld/idempotent hints, so the description carries full disclosure of behavior. It reveals the internal token-overlap matcher, the conditions under which compatibility warnings (e.g., event_subject_mismatch, temporal_mismatch) appear, the exclusion of unclassified legs, the fee disclosure (gross not net), and the fact that pairing is keyword-based, not source-verified. This is deep, explicit behavioral context far beyond annotations.

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

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

The description is lengthy but well-structured with clear labeled sections (RESPONSE, SAFETY FIELDS) and a front-loaded purpose. Every sentence delivers operational information—no filler. There is minor redundancy (e.g., 'BOTH modes run the identical token-overlap matcher' and later 'in EITHER mode'), but given the tool's complexity (multiple warning codes, edge cases), the length is justified. It could be tightened slightly, but remains efficiently organized.

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

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

With no output schema, the description must specify return fields, and it does thoroughly: top_spreads_pp, compatibility_warning, compatibility_codes, skipped_unclassified, low_confidence_pairs, temporal_alignment, fees_note, and counters. It also explains the meaning of null temporal alignment and provides operational clarity on interpreting flags. For a tool with this many edge cases (temporal mismatch, unclassified legs, gross spreads), the description leaves nothing essential 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?

The input schema already documents each parameter with descriptions and examples (100% coverage), so the baseline is 3. The description enhances meaning by explaining how parameters function: topic 'auto-fetch[es] the matching event', explicit tickers/slugs 'override' the mapped side, and both modes run the same matcher. It also warns that most pre-mapped topics currently yield compatibility warnings, adding semantic nuance about reliability.

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

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

The description clearly states the tool's function: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It names the specific resource (spread between two prediction venues) and distinguishes itself from siblings like polymarket_arbitrage (which likely focuses on real-time arbitrage) by emphasizing same-question comparison. Two explicit modes (topic shortcuts and explicit tickers) are described, making the purpose concrete and distinctive.

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 each mode: topic shortcuts for pre-mapped macros, explicit tickers for custom pairings, and notes that both run the identical matcher. It provides strong context on limitations ('Real cross-venue spreads are rarer than the macro-shortcut list suggests', 'pre-mapped ≠ tradeable'), guiding appropriate use. However, it does not explicitly name alternative tools (e.g., polymarket_arbitrage) or state conditions to prefer them, so the guidance is contextual but not exclusionary.

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 convey readOnly and idempotent behavior. Description adds scoping to user identifier and the listing behavior, which is useful context beyond annotations.

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

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

Three sentences, front-loaded with the primary action, no fluff. Excellent structure and conciseness.

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

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

Given one optional parameter, no output schema, and rich annotations, the description is complete: covers purpose, usage, scoping, and pairing. No gaps.

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

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

Schema coverage is 100% and the property description already covers omitting key to list all. The description re-emphasizes this but adds no new parameter semantics.

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, using specific verbs and resources. It distinguishes from siblings like remember and forget.

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

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

Provides clear context for when to use: to look up stored context without re-deriving. Mentions pairing with remember/forget, but lacks explicit when-not-to-use or alternatives among many siblings.

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

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

Annotations already indicate readOnlyHint=true and idempotentHint=true. The description adds valuable behavior beyond annotations: setting mark_read=true flags events as read, affecting subsequent calls. 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 with no superfluous words. It front-loads the core purpose, then explains parameters and usage. 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 rich annotations, full schema coverage, and no output schema, the description adequately covers return fields, side effects (mark_read), and polling suitability. It also provides an alternative access method, making it complete.

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

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

Schema coverage is 100% with descriptions for all 5 parameters. The description adds no new meaning beyond summarizing schema entries, which meets the baseline for high schema coverage.

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

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

The description clearly states the tool pulls fired events from subscription feed, returns recent alerts with source, citation_uri, and raw payload. It distinguishes the tool from siblings by specifying its unique function.

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 usage: filtering by type and since, setting mark_read, and notes that polling works fine. It also mentions an alternative access method, though it does not explicitly exclude other 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, idempotentHint, destructiveHint=false. The description adds behavioral details: fans out to multiple sources, fallback logic, and soft-failure for USPTO. It does not mention any side effects beyond those implied by 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 and front-loaded with keywords and examples. It covers all necessary aspects without being overly verbose. Minor redundancy (e.g., repeating 'company' multiple times) but overall efficient.

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

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

Despite no output schema, the description explains the return structure (changes[], total_changes, citation URIs). It covers sources, parameter details, and fallback behavior. Could mention pagination or result limits, but current level is adequate for the tool's complexity.

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

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

Schema coverage is 100%, but the description adds significant meaning: explains since parameter format with examples and a recommended default, clarifies value parameter accepts ticker or CIK, and provides context for type (only company supported).

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

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

The description clearly states the tool's purpose: a change feed for a company over a recent window. It provides concrete use-case examples ('What's new with X', 'latest on Y') and explicitly differentiates from the sibling tool entity_profile by stating when to use each.

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

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

The description gives explicit guidance on when to use this tool (for change feed queries) and when to use entity_profile instead. It also explains fallback behavior (GDELT preferred, GNews on rate limit/5xx) and limitations (USPTO soft-fail).

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 suggest a write operation (readOnlyHint=false) with idempotency (idempotentHint=true) and no destruction (destructiveHint=false). The description adds essential context: persistence duration for authenticated vs anonymous users, scoping by identifier, and the key-value storage model. 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 four sentences, front-loaded with the main purpose, followed by usage guidelines and technical 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's simplicity (2 params, no output schema), the description fully explains its purpose, usage context, lifetime behavior, and relationship with sibling tools. No gaps remain.

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

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

Schema coverage is 100% with clear descriptions for both 'key' and 'value'. The description does not add new parameter details beyond the schema examples, so it meets the baseline but does not exceed 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 uses the specific verb 'save' with the resource 'data the agent will need to reuse later'. It clearly distinguishes the tool from siblings by explicitly naming 'recall' and 'forget' for retrieval and deletion.

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

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

The description states 'Use when you discover something worth carrying forward' and references sibling tools for retrieval and deletion. However, it does not provide explicit conditions when not to use the tool.

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

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

Beyond the annotations, the description discloses important behavior: ambiguous names return `figi_candidates`, unresolvable identifiers appear under `unresolved`, and enrichment degrades gracefully when GLEIF or OpenFIGI is unavailable. It also documents ownership data, ISIN-to-LEI mapping, and source-labelled identifiers, which helps the agent predict results.

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

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

The lead is front-loaded and the content is dense, but the SUPPORTED TYPES block is one long nested paragraph with multiple parentheticals, making it harder to parse than necessary. Some explanatory phrases are not strictly needed for invocation and could be restructured into cleaner bullets.

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 2-parameter tool with no output schema, the description covers supported entity types, accepted input forms, return contents, ambiguity handling, unresolved outputs, and degraded availability. An agent has nearly everything needed to call 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?

Although schema coverage is 100%, the description adds the ISIN input form that the schema's value description omits, and it explains ticker-implied matching versus name search. The schema already covers the entity-name-only rule, so together the parameter semantics are strong.

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

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

The description opens with concrete trigger phrases and a clear definition: resolving a user-spoken name to canonical/official identifiers that other tools require as input. It names the two supported entity types and positions this tool as the one that supplies the IDs others need, which distinguishes it from siblings like entity_profile or compare_entities.

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 routing rule. It also lists accepted input forms and explains how ambiguous bond matches are handled. However, it does not name specific sibling tools or give explicit when-not-to-use conditions.

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

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

Annotations already indicate safe, idempotent, read-only behavior. Description adds key behavioral details: probes each entity with ai_visibility_check, ranks by score, treats first entity as subject, and returns score/confidence/signal density per entity.

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

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

Two sentences plus a usage example, all front-loaded. Efficient, no wasted words.

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

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

Despite no output schema, the description explains what is returned (score, confidence, signal density). Sufficient for a tool that aggregates results from another 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 clear parameter descriptions. Description does not add significant new semantic meaning beyond summarizing the schema.

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

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

Description clearly states the tool compares AI visibility across multiple entities, uses ai_visibility_check internally, ranks results, and returns a ranked list. It distinguishes from siblings like ai_visibility_check (single entity) by emphasizing side-by-side comparison.

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 mentions use case (competitive AI-marketing audits) with an example question. Does not explicitly state when not to use or list alternatives, but context makes it clear.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. Description adds valuable context: composite nature fans out across two services, partial failures degrade gracefully, bundlephobia first measurement can take 5-30s, sources_failed will list failures. 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 a single paragraph but well-organized, front-loading purpose and usage, then covering composite behavior, return format, ecosystem scope, and failure handling. Every sentence adds value, though could benefit from more structuring (e.g., bullet points).

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, multiple services, partial failures, timing), the description covers all important aspects: return format details (summary block, per-advisory detail, links, alternative versions) and failure behavior. No output schema, but description adequately explains what is returned.

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

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

Schema description coverage is 100% with good descriptions for both parameters. The description adds context about default version behavior and scoped package acceptance, but the schema already provides adequate documentation. Baseline 3 is appropriate.

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

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

The description clearly states the tool performs a composite check for evaluating npm packages, combining deps.dev and bundlephobia data. It uses specific verbs ('scan', 'fans out') and distinguishes from siblings by being a one-call composite for npm packages.

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

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

Explicitly says 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"'. It also notes NPM ecosystem only in v1, and describes partial failure behavior. Provides clear when-to-use and ecosystem constraints.

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

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

The description adds significant behavioral details not covered by annotations: embedding model (BGE-base-en), window size (500-char overlapping), character cap (200K chars), truncation behavior, and return fields (passages, offsets, similarity scores). No contradictions with annotations.

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

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

The description is well-structured, front-loading the core action and then providing technical details. It is detailed but not overly verbose, though minor trimming could improve conciseness.

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

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

Despite no output schema, the description covers return value semantics (passages, offsets, similarity scores). It also includes embedding and size limit details, and suggests complementary tools. This is comprehensive for a 3-parameter tool without output schema.

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

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

Schema coverage is 100%, and the description adds value for each parameter: 'text' gains max size, 'limit' gains range and default, 'query' gains examples and clarification of natural-language query. This enhances understanding beyond the schema.

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

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

The description clearly states it performs semantic search inside a fetched record, specifying the inputs (text and query) and the output (top-N passages with offsets and scores). It distinguishes itself from sibling tools by mentioning pairing with ask_pipeworx_grounded and highlighting the benefit of saving context.

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

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

The description explicitly tells when to use this tool: when the record is too big to cram into the prompt. It also suggests pairing with ask_pipeworx_grounded as an alternative workflow. It does not explicitly list when not to use, but the guidance is clear enough.

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

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

The description discloses many behavioral traits beyond annotations: prerequisites, type-specific parameters, delivery channel constraints (email/sms require verification, sms 10/day cap, webhook auto-disable after 10 failures, signing secret returned once). It does not contradict annotations and adds significant value.

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 and front-loads the main purpose. Each sentence adds value, though it is somewhat verbose with extensive examples. Still efficient for the complexity.

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

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

Given the complexity (nested objects, 3 parameters, no output schema), the description fully covers all aspects: types, delivery, constraints, and return. It leaves no significant gaps.

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

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

Schema coverage is 100%, and the description adds concrete examples and usage notes for each parameter, including type-specific structures for 'params' and detailed delivery options, far exceeding what the schema alone provides.

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

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

The description explicitly states it creates a proactive monitoring subscription to a live-data event stream and returns the new subscription ID. It distinguishes from sibling tools like 'list_subscriptions' and 'recall' by focusing on creation.

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 prerequisites (Pipeworx OAuth account, not anonymous/BYO) and explains supported types and delivery channels. It implicitly differentiates from tools like 'recent_alerts' for pulling data but does not explicitly list when not to use.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds context that the tool returns example questions drawn from the live catalog, and suggests calling with no args for full spread. 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 relatively concise given the information density. It front-loads common aliases, explains return format, and covers usage. Every sentence adds value with no wasted words.

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

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

For a discovery tool with no output schema, the description fully explains what it returns (category-bucketed examples) and how to use the optional topic parameter. It also mentions meta-tools to learn calling conventions, making it complete for an agent unfamiliar with the system.

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

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

Schema coverage is 100% with a single optional parameter described. The description adds value by explaining default behavior (full spread without topic) and listing valid topic values, which goes beyond the schema's brief description.

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

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

The description clearly states the tool's purpose as an onboarding entry point for an agent to learn what questions to ask Pipeworx. It lists aliases and explains that it returns category-bucketed example questions with tool+argument shapes, distinguishing it from other tools like ask_pipeworx.

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

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

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you'. Also explains optional topic parameter for focusing. While no explicit when-not, the context makes it clear this is for initial discovery.

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 that rows are deactivated (not deleted) and historical events remain available via recent_alerts, adding context beyond annotations that only indicate idempotency and non-destructiveness.

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

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

Two sentences efficiently convey the purpose, ownership constraint, and deactivation behavior with no wasted words.

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

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

For a simple one-parameter tool, the description fully covers the action, parameter source, ownership, and effect on historical data, making it complete and 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?

The schema already covers the parameter id with a description, but the description adds value by linking it to the subscribe tool, enhancing semantic clarity.

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

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

The description clearly states the action 'Cancel a subscription by id' with a specific verb and resource, and distinguishes from sibling tools like subscribe and list_subscriptions by focusing on cancellation.

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 specifies when to use the tool (to cancel your own subscription) and adds ownership enforcement, but does not explicitly mention when not to use it or provide alternatives.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description goes further by disclosing the return verdict types, the critical semantic distinction between 'could_not_verify' (check did not happen) and 'unsupported' (no source), the error structure verification_error{stage,detail}, and the fact that it replaces 4–6 sequential calls. This provides rich behavioral context beyond annotations.

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

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

The description is long but every sentence earns its place. It front-loads the purpose and trigger phrases, then logically explains routing, return values, and error semantics. The structure is tight and information-dense without fluff, appropriate for a tool of this complexity.

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

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

With no output schema, the description fully explains return values (verdicts, evidence, reasoning) and edge cases. It covers all aspects of the tool's behavior, including the two processing paths and error semantics. The description is complete for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, but the description adds meaning beyond the schema: it clarifies that 'claim' should be natural-language, gives concrete examples, and explains that 'tolerance_pct' overrides the tolerance implied by the claim wording, with a default capped at 5 and use cases for hallucination detection. This fully compensates and enriches the parameter definitions.

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

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

The description clearly states the tool's purpose: natural-language claim verification against authoritative sources, with a specific verb 'verify' and resource 'claim'. It distinguishes itself from siblings by explicitly describing the SEC EDGAR/XBRL structured fast path versus the grounded pipeline for any other factual claim, and provides trigger phrases like 'fact check' and 'is it true that'.

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 says 'Use whenever the agent needs to check whether something a user said is factually correct,' which is explicit when-to-use guidance. It also describes the fallback routing for any other factual claim. However, it does not explicitly name alternative tools to use when not a claim, nor does it state specific when-not-to-use conditions, so it falls slightly 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 declare readOnlyHint=true and destructiveHint=false, so the description does not need to repeat that. It adds value by stating the data source (National Treasury eTenders OCDS API) and listing the specific fields returned, giving the agent a concrete idea of what the tool provides beyond the schema.

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

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

The description is three sentences, each with a distinct purpose: state action, detail output, and provide input sourcing guidance. It is front-loaded and contains no unnecessary words.

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

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

Given the tool's simplicity (one required parameter, no output schema), the description covers all necessary information: what it does, what it returns, and how to get the input. It also references the sibling tool for input, making the tool's place in the workflow clear.

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

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

With 100% schema description coverage, the baseline is 3. The description adds extra value by providing an example ocid ('ocds-9t57fa-160595') and instructing the user to get an ocid from za_search_tenders, which aids in correct parameter selection.

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

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

The description uses a specific verb ('Get') and identifies the resource ('full OCDS release for a single South African government tender by its ocid'). It lists the concrete fields returned (description, tender period, documents, etc.) and distinguishes from the sibling tool za_search_tenders by explaining that ocid comes from it, making the tool's role 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 tells the user to obtain an ocid from za_search_tenders before using this tool, providing a clear usage context. It does not explicitly mention when not to use it or compare to other siblings, but the guidance is sufficient for a focused single-parameter tool.

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

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

Discloses that a date range is required by the upstream API and default behavior if omitted. Aligns with annotations (readOnly, idempotent, non-destructive) and describes return shape, with no contradictions.

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

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

Two efficient sentences covering purpose, usage, behavior, and parameter hints, with no wasted words. Front-loaded with key information.

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

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

With no output schema, the description adequately specifies return fields. Complexities (date range, pagination, related tool) are addressed, making the definition 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?

Adds meaning beyond schema coverage (100%) by clarifying that date_from/date_to are effectively required despite defaults, and noting max page_size, helping the agent use parameters correctly.

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 searches South African government tenders from a specific API, with examples and a preference over web search, distinguishing it 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?

Explicitly says to prefer this over web search for SA tenders, gives example queries, and directs to za_get_release for full detail, providing clear when-to-use and when-not-to-use guidance.

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