Gtin

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable behavioral context: default model choice, billing model for Anthropic calls (BYO key), return structure (per-model score, confidence, signals, raw_response + combined view). 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 concise (3 sentences) and well-structured: first sentence states core purpose and default, second covers optional probing, third summarizes return and use cases. No superfluous 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?

All aspects are adequately covered: purpose, parameter details (defaults, optionality, billing), return format, and use cases. Despite no output schema, the description provides sufficient return structure. Complexity is moderate with 4 params, and the 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 description coverage is 100%, providing a baseline of 3. The description adds meaning beyond schema by explaining the default model (Workers AI Llama-3.3-70b) and the billing arrangement for the _apiKey parameter, plus clarifying the context parameter's disambiguation purpose.

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

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

The description clearly states the verb 'probe' and resource 'LLMs for entity knowledge', scoring visibility 0-100 per model. It distinguishes from sibling tools like scan_competitor_ai_presence by specifying use cases for AI-marketing audits, pre-launch checks, and competitive monitoring.

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

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

The description provides clear context for when to use the tool (AI-marketing audits, brand checks, competitive monitoring) and explains the default model vs. requiring an API key for Anthropic. However, it does not explicitly state when not to use it or mention alternatives among sibling tools.

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

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

Annotations already establish read-only, open-world, idempotent behavior; the description adds useful operational context: it routes across 5,743 tools, fills arguments automatically, and returns structured answers with stable pipeworx:// citation URIs. This goes beyond the annotations without contradicting them, though it does not disclose any failure modes or limits.

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

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

The description is verbose and repetitive: the example list appears twice, and the final sentence about breaking-news packs is garbled and redundant. The useful guidance is front-loaded, but the duplicated examples and trailing malformed phrase make it longer and harder to scan than necessary.

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 routing tool with no output schema, the description covers what the tool does, when to use it, example inputs, and what the answer looks like (structured answer with stable pipeworx:// citation URIs). It is incomplete only in that it does not explain how this tool differs from its beta or grounded siblings or what happens when the routing fails.

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 all six parameters are documented aliases for the core 'question' parameter, so the schema already explains the input surface. The description adds meaningful guidance by listing trigger phrases, example questions, and the kinds of real-world factual requests that should be passed in, which helps an agent formulate the parameter value.

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

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

The description clearly identifies the tool as a natural-language question router that returns structured answers with citation URIs, so an agent knows what it does. However, it never differentiates this version from its siblings ask_pipeworx_beta and ask_pipeworx_grounded, so siblings could be selected incorrectly.

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, detailed when-to-use guidance: prefer over web search, use for listed data domains, use on trigger phrases such as "what is" and "look up", and start here for most questions. It does not, however, provide when-not-to-use guidance or point to sibling alternatives, so exclusions are missing.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds valuable context beyond those annotations: no candidate routing improvement is currently active, the tool currently matches ask_pipeworx exactly, and it is a full working router rather than a fallback.

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 long and front-loaded with the tool's identity and relationship to ask_pipeworx. Each sentence adds relevant information about current behavior, usage, or experimental status. It is slightly dense but not bloated.

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 beta alias of a known sibling tool, the description is largely complete: it explains current behavior, relationship to the stable router, how to invoke it, and that it is a full router. It does not describe the response format, but it references the same response shape as ask_pipeworx, which is an acceptable reference given the sibling context.

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

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

Schema coverage is 100% and the input schema already documents all aliases for the question parameter. The description only adds 'same arguments as ask_pipeworx,' which adds no new parameter-level meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly identifies ask_pipeworx_beta as a beta variant of ask_pipeworx: an identical universal router with the same 5,743 tools, arguments, and response shape. It distinguishes itself from the stable sibling by emphasizing the experimental edge, though it assumes some understanding of what ask_pipeworx does.

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

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

The description explicitly says to use it exactly like ask_pipeworx when you want the newest routing and explains that results are compared against the stable router. It provides a clear use case and a comparison to the stable sibling, though it does not explicitly state conditions where the stable version should be preferred.

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, openWorld, idempotent, and non-destructive behavior. The description adds meaningful behavioral context beyond these: it only answers from tool results, returns a structured refusal with specific reasons, includes verbatim evidence, and costs an extra LLM call. This fully discloses the tool's safety and refusal behavior without contradicting the annotations.

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

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

The description is dense but every sentence earns its place: purpose, routing behavior, return shape, refusal reasons, usage guidance, and cost. The most important distinction—grounded vs. casual—is front-loaded, and the structure is internally organized from behavior to usage.

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

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

Because there is no output schema, the description properly explains the return format, including success and refusal variants with refusal_reason enum values. It also covers when to use the tool, the alternative, and the extra cost. Nothing critical is missing for an agent to select and invoke this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add much parameter-level detail, but the schema already documents that question accepts aliases such as q, prompt, text, and input, which is sufficient for correct invocation.

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

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

The description clearly identifies this as a hallucination-resistant answer mode for high-stakes reads, distinguishes it from the sibling ask_pipeworx, and states what it does: extract answers only from tool results, with evidence and explicit refusals. It names a specific behavior and return shape, making the tool's purpose immediately recognizable.

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

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

The description explicitly says when to use this tool: whenever an answer will be quoted, cited, or acted on and the agent must not invent facts, with concrete examples like financial verdicts, legal claims, and medical lookups. It also explicitly directs users to prefer ask_pipeworx for casual lookups and discloses the extra LLM call cost, providing clear routing guidance.

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

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

The description extensively details behavioral traits such as market resolution, classification, fan-outs, response shapes, safety mechanisms, and edge cases. This goes far beyond the annotations (readOnlyHint, etc.), providing comprehensive transparency.

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

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

The description is lengthy but well-organized with multiple informative sections. It could be more concise, but every sentence adds value, making it effective for an AI agent.

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 (3 parameters, no output schema), the description covers input forms, response structure, safety, edge cases, and behavioral details thoroughly. It leaves no gaps for an agent's understanding.

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

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

With 100% schema coverage, the baseline is 3. The description adds value by explaining the 'depth' parameter (quick vs thorough) and 'include_raw' parameter effect, enhancing 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 explicitly states 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It also lists specific use cases like 'should I bet on X', distinguishing it from sibling tools like polymarket_arbitrage or 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?

The description provides clear use cases and examples of when to use the tool, but does not explicitly state when not to use it or mention alternatives. However, the context of sibling tools helps differentiation.

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

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

Adds significant context beyond annotations: describes data sources (SEC EDGAR, FAERS), handles off-calendar fiscal years, mentions sorting by primary metric, and states it returns citation URIs. 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?

Front-loaded with query examples, each sentence adds value. Slightly verbose but appropriate for the complexity; 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?

Covers all necessary aspects: purpose, usage, data sources, sorting, output format (paired data + citation URIs), and edge cases (off-calendar fiscal years). No output schema, so description adequately explains return structure.

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

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

Schema coverage is 100%, but the description adds meaning by explaining what each enum value ('company' vs 'drug') pulls and gives examples for the 'values' parameter. This enriches the schema beyond the baseline.

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

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

The description clearly identifies the tool as for side-by-side comparison of 2-5 companies or drugs, with specific verbs like 'compare' and examples of user queries. It distinguishes from siblings like entity_profile by noting it replaces multiple 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 instructs 'ALWAYS PREFER over sequential single-pack lookups when comparing entities', providing clear when-to-use guidance and naming the alternative approach.

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

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

Even with annotations covering read-only, open-world, and idempotent behavior, the description adds substantial context: account and paid-tier requirements, latency expectations, the findings-packet format, gaps[] and contradictions[] semantics, never-invented behavior, and semantic excerpting of large records. There is no contradiction with the annotations.

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

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

The description is dense and information-rich, and the most critical constraints are front-loaded: account requirement, alternative tool, and core scope. However, it is one long unbroken paragraph with many parentheticals and semicolons, which reduces scannability compared to a structured or list-based layout.

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 takes on the responsibility of explaining return values: findings packet fields, citation_uri fetchability, gaps[], contradictions[], and processing time. Combined with rich annotations and complete parameter schemas, an agent has everything needed to invoke this tool correctly.

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

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

Schema description coverage is 100%, and the schema already thoroughly documents both parameters, including depth enum behavior and the fact that broad/multi-part questions are supported. The description mostly restates this context rather than adding new parameter-level meaning, so it stays at the baseline.

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

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

The description names a specific operation, grounded multi-source research, and a specific resource, Pipeworx's 1,500 structured data sources. It also distinguishes itself from open-web search and from the ask_pipeworx sibling by explaining its parallel decomposition across 5,743 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 says when to use this tool, broad or multi-part questions over structured data, and when not to use it, single lookups and breaking/current news, naming ask_pipeworx as the alternative in both cases. It also adds an auth-based exclusion: unsigned-in users should use ask_pipeworx instead.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds beyond this by detailing the return format: 'Returns the top-N most relevant tools with names, descriptions, and full input schemas (with curated examples) — each result is ready to call directly, no second schema lookup needed.' This is rich context that helps the agent understand the behavioral outcome without contradicting 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 concise. It front-loads the core purpose and use cases in the first sentence, then provides additional details on return format and when to call it. Every sentence adds value without redundancy. It is appropriately sized for the tool's complexity.

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

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

Given the tool's role as a discovery tool with 100% schema coverage and safety annotations, the description covers what an agent needs to know: purpose, usage guidance, and return format. It doesn't detail ranking or ambiguity handling, but for a tool of this complexity, it is sufficiently complete. A 5 would require more specifics on edge cases.

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

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

Schema description coverage is 100%, with all parameters documented. The description adds value by listing the multiple aliases for the query parameter (q, task, search, description) and providing examples. It also explains the limit parameter's default and max. This goes beyond the schema's baseline, making it a 4.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It specifies the verb (find/discover) and resource (tools). The description also distinguishes itself from sibling tools by explicitly positioning it as a discovery tool for browsing available tools, which is distinct from specific research or utility tools like deep_research or validate_gtin.

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 guidance: 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' It also lists domains where the tool is useful (SEC filings, financials, etc.), helping the agent decide when to use it. However, it does not explicitly state when not to use it or mention alternatives, which would make it 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?

Goes far beyond the readOnly/idempotent hints by disclosing parallel fan-out across SEC EDGAR, XBRL, USPTO, USAspending, and more; the semantics of sources_used/sources_failed; the USPTO API sunset soft-fail; and the meaning of empty sections. It also details return fields like resolved_from/resolved_to and recent_filings URIs, giving the agent a clear mental model of behavior.

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

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

The description is long but every sentence is actionable: trigger phrases, usage preference, source list, return-field summary, and edge-case handling. It is front-loaded with core purpose and user examples, then dives into details relevant to correct invocation. Given the tool's complexity, this length is justified and well-structured.

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

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

This tool has no output schema, so the description carries the burden of explaining what the agent will receive. It does so comprehensively: input formats, resolved/private behavior, recent_filings with URIs, fundamentals, sources_used/sources_failed, and expected empty sections. Enough detail exists for an agent to invoke it correctly and interpret the response in all documented edge cases.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful extras beyond the schema: type values are interchangeable, value can be a ticker, CIK, or name, and names resolve via SEC EDGAR with explicit private-company behavior. This is a step above minimum viable, but not a large leap since the schema already contains good parameter 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 defines the tool as a single-call, cross-source profile of a US public company, with concrete query examples ('Tell me about X', 'company profile for Microsoft') and a specific resource scope. It distinguishes itself from chained SEC/XBRL/news lookups, which is the main alternative an agent might otherwise consider.

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

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

Explicitly instructs to 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' It also clarifies when results are expected to be sparse (e.g., FDA section for small-molecule companies) and that private companies return resolved:false rather than a hard error. Person/place use is implicitly excluded with 'coming soon.'

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

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

Annotations already provide destructiveHint=true and readOnlyHint=false. The description adds usage context but does not discuss idempotency or error behavior beyond what annotations imply.

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

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

Two sentences: first states purpose, second provides usage guidance. No redundant 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 with annotations present, the description fully covers purpose, usage, and sibling pairing.

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 simply echoes the parameter's purpose without adding new semantics. Baseline 3 applies.

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

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

The description clearly states the action (Delete) and resource (previously stored memory by key), and it distinguishes from sibling tools like remember and recall.

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

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

Explicitly states when to use (context stale, task done, clear sensitive data) and pairs with remember and recall for context.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint as false/true, so the safety profile is clear from annotations. The description adds that it fetches the page, extracts title/description/links, and outputs standard markdown. This aligns with annotations, but does not disclose any surprising behavior beyond what is obvious. The description adds moderate context but not enough to raise the score higher given 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 a single paragraph that front-loads the main purpose. It is concise but could be slightly more structured (e.g., bullet points for use cases). Every sentence adds value, and there is no fluff. Scoring 4 instead of 5 due to minor structural improvement possible.

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 (2 parameters, simple read-only behavior, no output schema), the description fully covers what the tool does, what it fetches, what format it outputs, and common use cases. It is complete for an AI 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 description coverage is 100%, with both parameters described in the schema. The description mentions the URL and implies a limit on links (max_links) but does not add significant meaning beyond the schema. Baseline score of 3 is appropriate since the description does not compensate for any gaps.

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

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

The description clearly states the tool generates a production-ready llms.txt file, using verbs 'generate', 'fetches', 'extracts', and 'emits'. It specifies the resource (llms.txt) and distinguishes from sibling tools by listing concrete use cases (indexing client sites, drafting for own project, auditing competitor).

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 use cases: getting a client's site indexed, drafting for one's own project, or auditing a competitor. It implies when to use this tool versus alternatives, but does not explicitly state when NOT to use it, which would strengthen the guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint, so safety and idempotency are clear. The description adds minimal behavioral context beyond the algorithm (mod-10). No contradictions.

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

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

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

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

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

For a simple computational tool with one parameter and rich annotations, the description covers purpose and usage. It could mention the return value format, but is adequate.

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

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

Schema coverage is 100% with a clear description of the 'data' parameter. The description reinforces that it should be digits except check digit, but adds little beyond the schema.

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

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

The description clearly states the tool computes the mod-10 check digit for GTIN/EAN/UPC data digits, excluding the check digit itself. It distinguishes from the sibling tool 'validate_gtin' which validates the full GTIN.

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 to generate or repair a barcode,' providing clear context. It does not explicitly list when not to use, but the sibling tools imply alternatives.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. Description adds contextual detail about return fields and scope. No contradictions.

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

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

Two sentences, front-loaded with purpose and return format, followed by usage guidance. No extraneous words.

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

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

Given the simple tool (one optional param, no output schema), the description fully covers purpose, return format, and usage. No missing information.

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

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

Schema coverage is 100% with a clear description for the only parameter. Description implies default behavior (active only) but adds no new 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?

Clearly states it lists 'the caller's active subscriptions' and specifies the return fields. Distinguishes from sibling tools like subscribe and unsubscribe by being a read operation.

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

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

Provides explicit guidance: 'Use this to review what you're monitoring before adding more or to find an id to cancel,' indicating when to use it versus alternatives.

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

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

All annotations are false, so description carries the behavioral burden. It discloses rate limiting (5/day/identifier), quota exemption, claim_token mechanics for follow-up, and a 'don't paste the end-user's prompt' rule. This adds real behavioral context beyond the bare false hints.

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

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

Dense, front-loaded purpose and organized sections. Each sentence earns its place (exclusions, token flow, rate limits), though length is on the higher side for a simple feedback tool.

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

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

Given the moderate complexity (4 params, nested object, no output schema), the description covers the full workflow: what to submit, how to frame it, follow-up via claim_token, and expectations (rate limit, quota). Ambiguity exists about account-based responses, but core usage is 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?

Schema covers 100% of parameters with descriptions, so baseline is 3. Description adds minor context (example claim_token call and guidance to describe issues in terms of Pipeworx tools/packs), but doesn't substantially elevate 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 opens with 'Tell the Pipeworx team something is broken, missing, or needs to exist,' a specific verb and resource. It clearly distinguishes itself from sibling research tools by framing actionable feedback categories (bug, feature, data_gap, praise).

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

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

Explicitly states when to use: for bugs, feature/data_gap requests, or praise. It gives an exclusion criterion: only for tools served by this Pipeworx connection, and directs other-server issues elsewhere, with a disambiguation ('Not sure? Pipeworx tool names are the ones this connection lists').

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

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

Adds valuable behavioral context beyond annotations: data source (CF analytics-engine), privacy (no PII), caching behavior (5min-1h). Annotations already signal safety (readOnly, idempotent, not destructive), and description complements without contradiction.

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

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

Concise and well-structured: two sentences for core function, bulleted use cases, and a final line on data source and caching. Every sentence serves a purpose 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 simple input schema (1 optional param) and no output schema, the description fully covers what the tool returns (top tools, packs, volume) and usage context. Caching and non-PII nature further inform agent behavior. 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 has 100% coverage for the single parameter 'window' with enum and description. Description adds value by explaining the semantic difference between short and long windows (hot vs. steady-state demand). Baseline 3 elevated to 4 for extra guidance.

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

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

The description explicitly states the tool returns top tools, top packs, and total call volume over a window, with three clear use cases. It distinguishes itself from sibling tools by focusing on trending data rather than discovery or other functions.

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 three explicit use cases for when to use the tool. It does not mention when not to use, but the context of trending vs. historical is implied by window choices. Slightly missing explicit exclusion criteria.

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 readOnly, openWorld, idempotent, non-destructive. The description adds extensive behavioral context: monotonicity violations, partition checks, Jaccard similarity filtering, placeholder filtering, and fill check against CLOB depth. 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 into paragraphs with clear sections. It is front-loaded with the main purpose and modes. Some details (e.g., Jaccard threshold, placeholder fraction) could be more concise, but overall it is 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 tool's complexity and lack of output schema, the description covers modes, partition checks, fill checks, and response structure. It lacks explicit error handling or limitations, but for a read-only analysis tool, it provides sufficient context for an AI agent to use it correctly.

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

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

Schema description coverage is 100%, but the description adds significant value: for 'event' it explains walking child markets and partition checks; for 'topic' it explains cross-event scanning and Jaccard similarity. Examples of acceptable values are provided, enhancing understanding beyond the schema.

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

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

The description clearly states the tool's purpose: finding arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes three modes (no args, event, topic) with concrete examples. While sibling tools exist, the description's specificity differentiates it effectively.

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

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

The description provides explicit when-to-use guidance: 'Call with NO args for a trending_scan', 'pass event for...', 'topic for...'. It recommends event mode for specific markets and topic for cross-event scanning. It also advises when not to trade (if realizable_edge_pp ≤ 0) and mentions polymarket_fill_risk for custom sizing.

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

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

The description far exceeds the annotations by detailing internal model logic (e.g., 'lognormal barrier from 90d FRED log-returns', 'partition_overround with favorite-longshot bias correction'), edge calculation, caching strategy (1h KV-level), and output structure including diagnostics for empty segments. No contradictions with annotations (readOnly, openWorld, idempotent, non-destructive).

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

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

The description is long but well-structured, starting with the purpose, then dividing into model families, response fields, and knob explanations. Every sentence adds meaningful detail. However, it could be more concise by condensing some technical explanations. The front-loading of purpose is effective.

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

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

Given the complexity (9 parameters, no output schema), the description thoroughly explains the response shape: by_segment with three segments, fed info, and diagnostics. It covers what each segment contains, edge metrics, and why certain edges are excluded. This compensates for the lack of output schema and ensures agents understand the full context.

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

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

All 9 parameters have schema descriptions (100% coverage). The tool description adds value by grouping parameters into 'TRADEABLE-EDGE KNOBS' and explaining their practical effect (e.g., 'drop opportunities where edge isn't realizable'). It also clarifies parameter behavior (e.g., min_kelly applies to single-leg, min_partition_leg_kelly to per-leg). This contextual guidance goes beyond the schema.

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

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

The description starts with a clear verb+resource combo: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It explicitly states the tool's purpose and its intended use case ('what should I bet on today'). The detailed breakdown of three model families and response segments further clarifies the specific outputs, distinguishing it from broader market 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 implies usage context ('agents discover opportunities without paging hundreds of markets') and provides adjustment knobs, but it does not explicitly state when to use this tool versus alternatives like polymarket_arbitrage or polymarket_edge_tracker. No 'when-not-to-use' or explicit exclusions are provided, though it does note Fed bets are excluded and why.

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 set readOnlyHint and idempotentHint to true; the description adds rich behavioral context: it reads from snapshots, returns tracked/expired/snapshot_dates, explains decay computation, and notes limits (60-day TTL, daily closes). No contradictions.

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

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

The description is dense but effective. It front-loads the purpose and uses clear structure (RESPONSE: with subparts, LIMITS). Minor improvement: could use bullet points for readability, but no wasted sentences.

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 2 optional parameters, no output schema, and moderate complexity, the description fully covers what the tool does, what it returns, and limitations. It is self-contained for an agent to decide and invoke correctly.

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

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

Schema coverage is 100%, baseline 3. The description adds value by explaining 'days' as lookback with clamp range and 'window' as snapshot family with defaults. It provides more context than the schema alone.

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

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

The description states a specific verb-resource pair: 'Edge persistence and decay telemetry' from 'daily polymarket_edges snapshots'. It answers a concrete question and implicitly distinguishes from the sibling 'polymarket_edges' by focusing on historical time-series and decay 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?

It explains the tool answers 'how long has this edge existed and is it shrinking?' and gives a concrete example contrasting fresh vs old edges. However, it does not explicitly state when NOT to use it or name alternative tools (beyond 'polymarket_edges'), which would strengthen this dimension.

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. Description adds rich behavioral context: walks the ladder, returns fill details, and warns that partial basket fills convert arb into unhedged directional position—the dominant loss mode. 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?

Dense and informative, but could be more structured (e.g., bullet points). Every sentence earns its place, but length is justified by complexity. Front-loaded with key 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?

No output schema, but description lists all return fields for both modes, explains risk scenarios, and covers edge cases. Complete for a tool of this complexity.

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

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

100% schema coverage, but description adds value: explains basket mode default side logic, size_usd clamp (10–1,000,000), and difference between market and event parameters. Goes beyond schema descriptions.

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

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

Description specifies a 'realizable-vs-theoretical edge check against live CLOB order-book depth' with clear single-market and basket modes. It distinguishes from siblings by stating 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'.

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

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

Explicitly advises when to use: before acting on arbitrage signals or trades above $500. Explains why not to use for thin books or partial fills due to directional risk. Clearly differentiates from sibling tools.

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

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

Beyond the readOnly/idempotent annotations, the description thoroughly discloses what the tool does NOT do: it does not model Kalshi fees, spreads are gross, and 'unknown' legs are never paired. It also explains that temporal_alignment null means 'could not be computed,' not 'aligned.' With safe read-only annotations, the description adds substantial behavioral context about matching heuristics and caveats.

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 information-rich, with clear section headers (TWO MODES, RESPONSE, SAFETY FIELDS), but it is very long for a tool description and repeats some details across compatibility codes and per-spread flags. It front-loads the core purpose and mode selection, but an agent must parse a large block to extract the key caveats.

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

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

Given no output schema, the description carries the full burden of explaining the response: it defines top_spreads_pp, compatibility_warning, compatibility_codes[], per-entry flags[], skipped_unclassified, low_confidence_pairs[], temporal_alignment, fees_note, and skipped_cross counters. It also explains edge cases like null alignment and non-equivalent bet shapes. An agent has enough context to call it correctly even without an output schema.

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

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

Schema coverage is 100%, so every parameter is already documented in the schema. The description adds context for topic values (auto-fetch shortcuts) and for the explicit ticker/slug overrides, but it does not add much meaning beyond the schema's own descriptions. 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 verb and resource — computing a cross-venue spread between Kalshi and Polymarket for the same resolving question — and differentiates it from siblings like polymarket_arbitrage and polymarket_edges by specifying the two-venue comparison and the token-overlap matcher. It also states what it is not (pre-mapped does not mean tradeable).

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

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

The description explicitly explains TWO MODES, which of the two to use for pre-mapped macro shortcuts (topic) vs custom pairings (explicit ticker+slug), and gives the exact 10 topic values. It also provides a use condition — BOTH modes run the identical matcher — plus a caution that most pre-mapped topics return compatibility_warning today. This is stronger than most tool descriptions.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so description adds context about listing all keys when no argument is provided and scoping to identifier. 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 three sentences, front-loaded with the main action, and 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 simple parameter (1 optional string) and no output schema, the description explains both retrieval and listing use cases completely. Could mention return format but not required.

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

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

Schema coverage is 100% and the description adds usage context (omit to list all keys) but doesn't provide additional parameter details beyond the schema.

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

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

The description clearly states the tool retrieves a value saved via remember or lists all keys when omitted. It distinguishes from sibling tools 'remember' and 'forget', and specifies the resource ('memory key').

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 states when to use (look up stored context) and pairs with remember and forget. It also mentions scoping and gives examples of use cases (target ticker, address, research notes).

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 states 'Set mark_read:true to flag returned events read,' implying a state change (marking as read) that contradicts the readOnlyHint: true annotation. Annotations indicate no modifications, but the description explicitly describes a write-like side effect. This is a clear 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-loading the core purpose. Every sentence adds value: purpose, return fields, filtering, mark_read behavior, and alternative access. No fluff or redundancy.

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

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

Given no output schema, the description adequately describes return fields (source, citation_uri, payload) and covers key behaviors (polling, alternative endpoint, mark_read semantics). It lacks details on error handling or pagination beyond the 'limit' parameter, but is otherwise 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%, but the description adds meaningful context beyond schema descriptions: it provides an example for 'type' ('sec_8k'), explains the purpose of 'mark_read' (so next call shows newer events), and relates 'since' to ISO timestamps. This enhances understanding beyond the schema alone.

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

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

The description clearly states 'Pull fired events from your subscription feed,' specifying a verb and resource. It distinguishes itself from siblings like 'list_subscriptions' by focusing on events rather than subscription details, and mentions an alternative HTTP endpoint for scripts, further clarifying its niche.

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 mentions polling suitability and points to an alternative HTTP endpoint for scripts/dashboards, giving clear guidance on when to use this tool vs. manual access. It does not explicitly contrast with other tools like 'recent_changes,' but the context is sufficient for most use cases.

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

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

Disclosed behavioral details beyond annotations: fans out to SEC EDGAR, GDELT→GNews fallback on rate limit/5xx, USPTO soft-fail due to API sunset. Annotations indicate readOnlyHint=true (safe read) and idempotentHint=true, which 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?

The description is dense but not verbose. Every sentence provides necessary information: purpose, examples, behavior details, parameter formats, and sibling differentiation. Front-loads the core purpose with query examples.

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

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

Despite no output schema, the description explains the return structure (changes grouped by source, total_changes count, pipeworx:// citation URIs). It covers all needed context for a complex multi-source tool with fallback behavior, leaving 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 description coverage is 100% for all 3 parameters, so baseline is 3. The description adds value by explaining the 'since' parameter formats ('7d', '30d', '3m', '1y') and recommending '30d' or '1m' for typical monitoring, which goes beyond the schema.

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

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

The description clearly states 'change feed for a company' with explicit query examples ('What's new with X', 'latest on Y'). It distinguishes from sibling entity_profile by specifying that entity_profile is for static profiles regardless of window.

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

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

Provides explicit guidance on when to use this tool ('for a company in the last N days/weeks/months') and when to use the sibling tool entity_profile instead. Includes example queries that clarify the use case.

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

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

Beyond annotations (idempotentHint=true, etc.), description adds key behavioral details: persistence behavior varies by authentication (permanent vs 24-hour), and scoping by identifier. No contradiction with annotations.

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

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

Four sentences starting with purpose, then usage, then behavior details. No redundant or unnecessary content. Every sentence is informative and earns its place.

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

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

Given simple input schema (2 required string params) and no output schema, the description fully covers purpose, usage, persistence, and relationships to sibling tools (recall, forget). 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 has 100% coverage with descriptions. Description adds naming conventions for keys (e.g., 'subject_property') and clarifies value is free text. Adds value beyond schema but schema already does most work.

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

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

Description specifies the verb ('Save data') and resource ('memory') with concrete examples ('resolved ticker, target address'). It distinguishes from sibling tools recall and forget, making the purpose 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?

Explicitly states when to use ('when you discover something worth carrying forward') and provides use cases. Notes pairing with recall/forget for retrieval and deletion, giving clear context for alternatives.

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

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

Annotations already declare readOnly/openWorld/idempotent, and the description adds substantial behavioral context: it cascades through multiple lookup endpoints, returns figi_candidates when ambiguity exists, reports unresolved identifiers explicitly, and degrades gracefully when GLEIF/OpenFIGI are unavailable while still returning EDGAR identifiers. This goes well beyond what annotations alone convey.

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

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

The description is long and dense, but the important guidance is front-loaded and organized with 'SUPPORTED TYPES' sections. The opening example list is somewhat redundant, and the parenthetical chains make it heavier than ideal, but nearly every sentence contributes operational 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?

For a tool with two required parameters and no output schema, the description is remarkably complete: it covers input formats, supported types, enrichment sources, ambiguity handling, unresolved results, degradation behavior, and even edge cases like non-US issuers. An agent has everything it needs to 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?

Even though schema coverage is 100%, the description enriches both parameters significantly. It explains type-specific behavior, gives accepted formats for value (ticker, CIK, ISIN, company name, drug brand/generic), and warns emphatically to pass only the entity name, not the full noun phrase — critical detail absent from the schema.

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

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

The description opens with concrete user phrasings and a crisp statement: resolve a user-spoken NAME to the canonical/official identifiers other tools require as input. It enumerates supported entity types (company, drug) and specific identifier outputs, making the tool's job unambiguous and distinct from siblings like entity_profile.

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

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

The description explicitly says 'Use FIRST whenever you have a name but need an ID,' giving a clear trigger condition. It also explains how this tool replaces 2-3 manual lookups, but it does not explicitly name alternative tools or state when not to use it, so the guidance falls just 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?

The description explains the tool probes each entity with ai_visibility_check, which is a specific behavioral trait. It also describes the output format (ranked list with score, confidence, signal density). Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, and the description is consistent and adds context beyond them.

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

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

The description is two sentences plus a parenthetical use-case note, all front-loaded and free of fluff. Every sentence provides essential 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?

Despite no output schema, the description covers the return format (ranked list with score, confidence, signal density) and explains the probing process. For a 4-parameter tool with full schema coverage, it is complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying that the first entity is treated as the 'subject' for narrative, which is additional meaning beyond the schema description for the 'entities' parameter.

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

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

The description clearly states the tool compares AI visibility across multiple entities, probes with ai_visibility_check, ranks by score, and surfaces most/least recognized. It distinguishes itself from sibling tools like ai_visibility_check (single entity) and compare_entities (generic comparison) by specifying its competitive audit purpose.

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

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

The description provides a concrete use case: 'competitive AI-marketing audits: does Claude know about us as well as our competitors?' This tells when to use the tool, though it does not explicitly mention when not to use or suggest alternatives like individual ai_visibility_check calls.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint false. Description adds valuable behavioral context: composite call fans out, partial failures degrade gracefully, bundlephobia first measurement may take 5-30s and will be listed in sources_failed if timed out.

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 detailed but every sentence adds specific information: purpose, usage, return structure, ecosystem limitation, failure behavior. Could be slightly more concise but is well-structured and informative.

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

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

Despite no output schema, description lists all return fields (summary block fields: is_latest, license, published_at, etc.), per-advisory detail, links, alternative versions. Covers inputs, behavior, and outputs completely for a two-parameter tool.

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

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

Schema covers both parameters with descriptions (100% coverage). Description adds that scoped packages are accepted and version defaults to latest, providing minor extra value beyond schema.

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

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

Description clearly states the composite purpose: 'should I add this npm package to my project' check aggregating deps.dev and bundlephobia data. It distinguishes itself from siblings by being the only dependency scanning 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 usage guidance: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"'. Also notes ecosystem limitation and alternatives: 'NPM ecosystem only in v1; PyPI / Maven / Cargo / Go fall under deps.dev:version directly'.

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 readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. Description adds embedding model (BGE-base-en), method (cosine over 500-char overlapping windows), char cap (200K chars truncated with flag), and that passages have offsets for verification.

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

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

Two sentences, front-loaded with core action. Efficiently packs use case, behavioral details, limits, and sibling reference without fluff.

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

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

Tool has 3 parameters, no output schema, no nested objects. Description covers purpose, when to use, behavioral details (model, method, limits), parameter specifics, and sibling integration. Complete for this complexity.

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

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

Schema description coverage is 100%, so baseline is 3. Description adds context: 'max ~200K chars' for text, 'default 5' for limit, and example queries for query parameter. This adds value beyond schema.

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

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

The description clearly states it performs semantic search inside a fetched record, specifying input (text and query) and output (top-N passages with offsets and similarity scores). It distinguishes from siblings by mentioning pairing with ask_pipeworx_grounded.

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

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

Explicitly states when to use: 'Use when the record is too big to cram into the prompt'. Mentions alternatives and integration: 'Pairs with ask_pipeworx_grounded: fetch with the gateway, ground over the relevant passages instead of the whole document'.

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 detailed behavioral context: persistence requirement, delivery limits, webhook signing secret, auto-disable after failures. However, it contradicts the idempotentHint annotation by implying each call creates a new subscription, which is not idempotent.

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

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

The description is comprehensive and well-structured with examples and options. While it is relatively long, the complexity justifies the detail; every sentence serves a 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 lack of output schema and nested objects, the description covers all necessary aspects: subscription types, parameters, delivery channels, account requirements, and return value. It leaves no obvious gaps for an AI agent.

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

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

Schema coverage is 100%, and the description significantly enriches each parameter with clear examples, constraints, and type-specific details (e.g., sec_8k items codes, fred_series series_id).

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

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

The description clearly states the tool creates a proactive monitoring subscription to a live-data event stream. It specifies the return value (new subscription id) and distinguishes from sibling tools like list_subscriptions and unsubscribe.

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

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

The description explains when to use the tool (for monitoring events) and details supported types with examples. It also mentions account requirements (Pipeworx OAuth) and constraints on delivery channels. However, it does not explicitly state when not to use or mention alternatives like list_subscriptions.

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

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

Adds significant context beyond annotations: describes return format (category-bucketed questions with tool+argument shape), sources from live catalog, and explains no-argument vs topic behavior. Consistent with readOnlyHint and openWorldHint.

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

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

Single paragraph with front-loaded query variants. Efficient but somewhat dense; every sentence contributes valuable 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?

Without output schema, description fully explains what the tool returns and the range of topics. Covers all necessary context for an onboarding tool.

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

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

Schema provides 100% coverage for 1 parameter. Description adds more detail on topic values (e.g., 'finance', 'pharma') and behavior difference when omitted, enhancing the schema.

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

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

The description clearly states the tool is the onboarding entry point for agents, returns category-bucketed example questions, and distinguishes from sibling tools by mentioning it's for getting started and learning meta-tools.

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

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

Explicitly recommends using this tool first when unsure of Pipeworx's capabilities and to learn meta-tools. Provides guidance on topic parameter to focus. Lacks explicit when-not-to-use, but context is clear.

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

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

Discloses mutability (readOnlyHint false), idempotency (idempotentHint true), non-destructive effect (deactivate not delete), and historical availability via recent_alerts. Adds significant context beyond annotations.

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

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

Two concise sentences: first states action and ownership, second explains behavioral nuance. 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 simple single-param tool, good annotations, and no output schema, description fully covers purpose, precondition (ownership), behavioral effect (deactivation), and cross-tool reference (recent_alerts).

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

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

Single parameter 'id' with schema description 'Subscription id (uuid) returned by subscribe.' Tool description mentions 'by id' but adds no further detail; schema coverage is 100%, so baseline 3 is appropriate.

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

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

Clear verb-resource pair 'Cancel a subscription by id' and distinguishes from siblings like subscribe and list_subscriptions.

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

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

States ownership enforcement ('you can only cancel your own subscriptions') and notes deactivation vs deletion, guiding when to use and how history remains. Does not explicitly name alternatives but context is clear.

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

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

Beyond the annotations (readOnlyHint, openWorldHint, idempotentHint), the description adds rich behavioral context: the two execution paths (SEC EDGAR fast path vs. grounded pipeline), the exact meaning of could_not_verify with verification_error{stage,detail}, and the crucial warning not to present could_not_verify as evidence. It also clarifies unsupported as a coverage outcome, fully disclosing edge-case behavior.

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

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

The description is dense but efficiently organized: trigger phrases, purpose, routing logic, return contract, and caller caveats are front-loaded. Every sentence contributes operational value (e.g., 'Replaces 4–6 sequential calls'), with no filler or redundant repetition of annotations/schema. It is long but each clause earns its place.

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

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

With no output schema, the description fully explains the return value structure: verdict, grounded/structured actual value with pipeworx:// citation, and reasoning. It covers the critical distinction between could_not_verify and unsupported, the source-routing logic, and the efficiency advantage, making the tool's behavior predictable for an agent even in odd edge cases.

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

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

The input schema already provides 100% coverage with detailed descriptions for both claim and tolerance_pct, including how tolerance_pct overrides the implied tolerance and its default cap. The description does not add new parameter-level semantics beyond the schema; it only reinforces the routing logic already present in the schema.

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

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

The description clearly identifies the tool as natural-language claim verification against authoritative sources, lists concrete trigger phrases, and enumerates the verdict types. It distinguishes itself from siblings by focusing on fact-checking ('confirm or refute') and by explicitly mapping financial claims to the structured SEC EDGAR path and other claims to the grounded pipeline, making its scope unmistakable.

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

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

The description explicitly states 'Use whenever the agent needs to check whether something a user said is factually correct' and provides a detailed routing guide for financial vs. non-financial claims. However, it does not explicitly name alternative tools or state when NOT to use this tool, so it falls short of the highest bar for usage guidance.

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

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

Annotations already declare safe, idempotent, non-destructive behavior. Description adds value by stating it validates the number (not product), ignores spaces/dashes, and is offline/keyless—context beyond structured 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 concise sentences, front-loaded with core action, then details. No fluff or repetition. Each sentence adds unique 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 one parameter, no output schema, and rich annotations, the description adequately explains what the tool returns (check digit verification, format, normalized GTIN-14, prefix, country). Could explicitly list all return fields for full completeness, but sufficient for an agent.

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

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

Schema covers 100% with one parameter, but description adds meaning: input can be from various formats, spaces/dashes ignored, and it normalizes to GTIN-14. This enhances understanding beyond the schema's basic description.

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

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

Description starts with 'Validate a barcode number' and lists specific formats (EAN-13, UPC-A, EAN-8, GTIN-14), making the tool's purpose very clear. It distinguishes from sibling gtin_check_digit by mentioning normalization and country retrieval.

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

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

Implies usage for validating barcodes of specific formats, but does not explicitly state when to use this tool versus the sibling gtin_check_digit or other tools. No when-not or alternative guidance provided.

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