Odoo

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds behavioral context: it probes LLMs, free default model, requires API key for Anthropic, passes key directly, and returns scores with confidence. Cost implications (BYO key) are disclosed.

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

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

The description is four sentences, front-loaded with purpose and action. Every sentence adds value: purpose, default behavior, return format, use cases. No wasted words.

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

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

Given the absence of an output schema, the description comprehensively covers the return format (per-model fields + combined view). Parameters are fully described, and annotations cover safety. No gaps.

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

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

Schema coverage is 100%. The description adds meaning beyond the schema: default model is free, '_apiKey' is for Anthropic and passed straight through, 'context' helps disambiguate. This provides useful context for the agent.

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 ('probe one or more LLMs'), the target resource ('business / brand / product / topic'), and the output ('score visibility (0-100) per model'). It specifies the return format and use cases, distinguishing it from sibling tools like ask_pipeworx or deep_research.

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

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

The description provides context for when to use the tool ('AI-marketing audits, pre-launch brand checks, competitive monitoring') and clarifies that it probes multiple models with a free default. However, it does not explicitly state when not to use it or mention alternative tools.

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

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

Annotations already establish read-only/idempotent behavior. The description adds behavioral context: it routes to the appropriate sub-tool, fills arguments automatically, returns pipeworx:// citation URIs, and explicitly notes it works on all tiers with one fast call. It does not contradict annotations, but could further disclose potential latency or failure modes.

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

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

The description is front-loaded with the key 'PREFER OVER WEB SEARCH' directive, but is quite long, including exhaustive list of data domains, trigger phrases, and examples. While every sentence adds value, the overall length slightly exceeds what is necessary for a single tool description.

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 router tool with no output schema, the description fully covers purpose, usage triggers, return format (structured answers with citation URIs), performance characteristics (fast, all tiers), and situated alternatives. It is comprehensive and self-contained.

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

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

The schema already documents the 'question' parameter and all aliases with 100% coverage. The description provides examples of effective questions but does not add parameter-level syntax or constraints beyond what the schema states. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly identifies the tool as a router for factual questions across 5,529 tools and 1,455 verified sources, returning structured answers with citations. It explicitly contrasts with sibling tools like ask_pipeworx_grounded and deep_research, establishing a distinct 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?

It provides explicit guidance on when to use this tool over web search ('PREFER OVER WEB SEARCH'), lists trigger phrases, and names specific alternatives for special cases ('for a hallucination-resistant single answer... use ask_pipeworx_grounded; for broad/multi-part... use deep_research').

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 substantial context beyond the annotations: it is an experimental beta, currently identical to ask_pipeworx because no candidate is active, and it is a fully functional router. This is valuable behavioral disclosure about potential routing changes during tests. No contradiction with annotations (readOnlyHint, etc.).

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 yet information-dense, with a clear structure: it leads with the beta status, explains the identical nature, states the current inactive candidate state, and gives usage guidance. Every sentence adds value, and the length is appropriate for the complexity of the 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?

The description fully addresses the tool's purpose, its relationship to the stable router, and its experimental nature. Even without an output schema, it references 'same response shape' which suffices given the identical-to-ask_pipeworx claim. The annotations cover safety, making the description 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?

The schema covers all parameters (100% coverage) with clear descriptions—all six are aliases for 'question.' The description only says 'same arguments' as ask_pipeworx, which is a reference rather than additional semantics. Since the schema already documents the parameters well, a baseline score of 3 is appropriate.

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

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

The description clearly identifies it as a beta version of ask_pipeworx, a universal router with 5,529 tools, and explicitly distinguishes it from the stable router via experimental routing improvements. The verb and resource are clear, and it differentiates itself from siblings (ask_pipeworx, ask_pipeworx_grounded) by its beta nature.

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 'Use it exactly like ask_pipeworx when you want the newest routing,' providing clear guidance on when to use it. It also explains that results are compared against the stable router, implying the stable alternative, though it doesn't explicitly say 'do not use for stable behavior.' This is clear context without a formal exclusion.

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 substantial behavioral context beyond the annotations: it explains the internal pipeline (routing, fetching, extraction), discloses that it refuses to answer when data is insufficient, and enumerates specific refusal reasons. It also reveals the cost implication of an additional LLM call, which is a behavioral trait not captured by annotations.

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

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

The description is comprehensive and well-structured, with a clear opening statement, a use-case directive, and a cost note. It contains many valuable details (return structure, refusal reasons) but is somewhat long; a slightly tighter wording could improve accessibility without losing important 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 having no output schema, the description fully specifies the return contract: a success object with answer, evidence, confidence, source, fetched_at, and refusal_reason, plus an explicit refusal object with enumerated reasons. This covers all necessary context for an agent to understand expected outputs and failure modes.

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 6 parameters are aliases for the question parameter, and the schema provides 100% description coverage. The description does not add additional parameter semantics beyond what the schema already explains, but the baseline of 3 applies because the schema fully documents the parameters.

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

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

The description clearly states the tool's core function: a hallucination-resistant answer mode for high-stakes reads. It specifies the exact behavior—routing through the same tool selection as ask_pipeworx, fetching data, and extracting the answer strictly from the tool result. This distinguishes it from the sibling ask_pipeworx by emphasizing its grounded, evidence-based nature.

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 defines when to use this tool: when an answer will be quoted, cited, or acted on, and for high-stakes scenarios like financial, legal, or medical lookups. It also contrasts with the cheaper alternative by stating 'prefer ask_pipeworx for casual lookups' and explains the trade-off of one extra LLM call.

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

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

Annotations declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false, indicating a safe read operation. The description goes beyond annotations by detailing the fan-out process, response shapes, resolver contract, parent event extraction, news fallback behavior, and safety mechanisms (e.g., low-confidence short-circuits, closed market status). 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 comprehensive and well-structured with clear sections (classifiers, fan-out examples, response shapes, etc.), but it is quite long. While every sentence adds value, it could be more concise without losing critical information.

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

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

Given the tool's complexity (3 parameters, no output schema), the description is exceptionally complete. It covers all aspects: input types, process, output shapes, edge cases (low confidence, closed markets, wide spreads, resolution rules), and provides actionable guidance for agents.

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

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

Schema description coverage is 100%, so the schema already defines parameters (market, depth, include_raw) with descriptions. The description adds value by providing examples, explaining defaults (quick vs thorough, include_raw false), and clarifying that market can be a slug, URL, or question text.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies input types (slug, URL, question text) and distinguishes itself from sibling tools like ask_pipeworx by focusing on Polymarket bets and providing a comprehensive evidence packet.

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

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

The description explicitly states when to use the tool: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It provides extensive guidance on inspecting results (market_match_confidence, parent_event, etc.) and warns about edge cases like low-confidence matches, closed markets, wide spreads, and resolution-rule risk.

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

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

Annotations indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable behavioral details: it fetches financial data from SEC EDGAR/XBRL with proper fiscal year handling, pulls FAERS data for drugs, sorts results by primary metric, and returns citation URIs. No contradictions with annotations.

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

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

The description is a single paragraph but front-loads the key purpose with trigger examples. It efficiently covers key details without excessive verbosity. However, it could be slightly more structured (e.g., separate lines for each entity type) for easier scanning.

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

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

No output schema exists, so the description must explain return values. It mentions 'paired data + pipeworx:// citation URIs per entity' and that results are sorted by primary metric. While this gives a general idea, it lacks specifics on the structure of the paired data. Given the tool's complexity and the presence of sibling tools, this is adequate but not fully comprehensive.

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

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

Schema coverage is 100% with descriptions for both parameters. The description enriches parameter semantics by explaining what to pass (tickers/CIKs for company, names for drug), adding examples, and describing the data fetched per type. This goes beyond the schema's basic description.

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

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

The description clearly states it performs side-by-side comparison of 2-5 companies or drugs, with specific verbs like 'compare', 'rank', 'head to head'. It distinguishes from sibling tools like entity_profile by focusing on multi-entity comparison vs. single-entity lookup.

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?

Description explicitly says 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' It provides example triggers such as 'which is bigger' and 'compare X and Y'. However, it does not explicitly state when not to use it, but that is implied by the comparison 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 declare read-only, but description goes far beyond by disclosing parallel facet decomposition, findings packet contents (verbatim evidence, confidence, source, fetched_at, citation_uri), gaps[] behavior, contradiction detection, semantic excerpting, latency expectations, and second-hop iteration semantics. 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?

Though long, every sentence carries essential information: prerequisites, alternatives, return structure, time expectations, and caveats. The description is front-loaded with the account requirement and structured with clear examples, making the density valuable rather than 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?

Even without an output schema, the description fully compensates by describing findings packet fields, citation URI semantics, gaps[] and contradictions[], excerpting behavior, and latency. Given the tool's complexity, this is a complete and self-sufficient description for an agent to select 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 provides complete parameter descriptions (100% coverage), giving a baseline of 3. The description adds meaningful nuance beyond the schema by explaining how 'depth' values alter hop behavior and gap recovery, and that 'question' is flexible for broad/multi-part queries. This extra context justifies above-baseline scoring.

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 defines the tool as grounded multi-source research over 1455 structured data sources, explicitly distinguishing it from open-web search and sibling ask_pipeworx. It includes concrete example use cases like 'compare X and Y's regulatory + financial exposure', making the purpose unmistakable.

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

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

Provides explicit when-to-use (broad/multi-part questions over structured data) and when-not-to-use (single lookups, breaking news) guidance, naming alternatives like ask_pipeworx. It also covers account prerequisites and tier-dependent behavior (paid for 'thorough' depth), which is comprehensive and actionable.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds valuable behavioral context: returns top-N tools with full schemas and examples, each ready to call without a second lookup. No contradictions.

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

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

The description is front-loaded with the purpose, followed by usage context and output details. Two sentences plus a call-to-action, no wasted words.

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

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

Despite no output schema, the description explains what the tool returns (top-N tools with names, descriptions, schemas, examples) and that each result is callable. This is sufficient for a discovery tool, though error behavior is omitted.

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

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

Schema description coverage is 100%. The description sets context for the query parameter but does not add significant meaning beyond the schema. 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 uses a specific verb ('Find tools') and identifies the resource ('tools by describing the data or task'). It clearly differentiates from siblings by positioning itself as a meta-tool for discovering other tools, and explicitly says 'Call this FIRST'.

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

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

The description explicitly states when to use ('browse, search, look up, or discover what tools exist') and contrasts with alternatives ('not just one answer'). It implies when not to use but lacks an explicit negative 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?

Adds context beyond annotations: describes fan-out across multiple sources, specific return fields, a sunset issue with patents, and soft-fail behavior. 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 multi-sentence but well-structured, starting with example queries and then explaining functionality. It is appropriately sized for a complex tool, though slightly verbose.

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 and no output schema, the description details return fields, limitations, fallbacks, and prerequisites. An agent has sufficient information to use the tool correctly without ambiguity.

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

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

Schema coverage is 100% so baseline 3. Description adds meaning: explains that 'value' can be ticker or zero-padded CIK, and that 'type' is currently limited to 'company'. This clarifies usage beyond the schema.

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

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

The description clearly states it provides a 'full cross-source profile of a US public company in ONE parallel call' with specific examples. It distinguishes from sibling tools like resolve_entity by noting that names are not supported and a ticker/CIK is required.

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 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view'. Also warns that names are unsupported and directs to use resolve_entity for names.

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. Description adds context about clearing sensitive data and that memory is saved earlier, supplementing safety information beyond annotations.

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

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

Two sentences: first states action, second gives usage guidance. No wasted words, front-loaded effectively.

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

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

Simple tool with one parameter and no output schema. Description fully addresses what, when, and relation to siblings. Annotations cover destructiveness. 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?

Only one parameter 'key' with schema description 'Memory key to delete' covers everything. Schema coverage is 100%, so baseline 3. Description adds no extra meaning beyond schema.

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

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

Description clearly states 'Delete a previously stored memory by key', specifying the verb (delete), resource (memory), and identifier (key). It distinguishes from siblings by mentioning pairing with 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 says when to use: when context is stale, task done, or clearing sensitive data. Also notes pairing with remember and recall, giving context on alternatives. Lacks explicit when-not guidance but adequate.

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

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

Annotations (readOnlyHint, idempotentHint, destructiveHint) already indicate a safe, non-destructive, idempotent operation. The description adds behavioral details beyond annotations: it fetches the page, extracts title/description/key links, and emits standard llms.txt markdown. It also states the output is a single text blob for site-root placement.

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 (two sentences plus a list of use cases), front-loads the main purpose, and every sentence adds value. No wasted words.

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

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

For a simple tool with 2 parameters and no output schema, the description covers the core functionality, process (fetch, extract, emit), output format, and use cases. It lacks notes on error handling or failure scenarios, but given annotations (openWorldHint) and simplicity, it is reasonably 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 description coverage is 100%, so baseline is 3. The description does not add new meaning to parameters beyond what the schema already provides (e.g., max_links default and max are in the schema). The description's overall behavioral context is already captured.

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

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

The description clearly states the tool generates a production-ready llms.txt file for any URL, specifying the verb 'generate', the resource 'llms.txt file', and the context 'for any URL'. It distinguishes from siblings as no other sibling tool performs this specific function.

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

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

The description lists three use cases (getting a client's site indexed, drafting for own project, auditing competitor) that indicate when to use it. It does not explicitly exclude scenarios or mention alternatives, but the use cases are clear and relevant.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the description doesn't need to re-state safety. It adds value by listing the return fields (id, type, params, created_at, etc.), providing transparency about the output beyond the schema.

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

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

Two sentences, no wasted words. The purpose is front-loaded, and the usage guidance is provided efficiently.

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

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

For a simple list tool with one optional parameter, the description covers purpose, return format, and usage context. Annotations cover safety. No output schema exists, but the description lists fields, which is sufficient.

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

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

Schema coverage is 100% and the parameter 'include_inactive' is already described in the schema. The description adds only implicit context by saying 'active subscriptions' (default) but doesn't explicitly explain the parameter's effect beyond the schema.

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

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

The description uses a specific verb ('List') and resource ('the caller's active subscriptions'), clearly distinguishing it from siblings like subscribe and unsubscribe by focusing on listing rather than creating or removing.

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

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

The description explicitly states when to use this tool: 'to review what you're monitoring before adding more or to find an id to cancel'. This provides clear context and implicitly tells when not to use it (e.g., for subscribing or unsubscribing).

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds value by specifying returned fields (name, contact, email_from, etc.) and the filter option by type, 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 composed of two concise sentences: the first describes purpose and returns, the second gives a usage hint. No extraneous information, effectively front-loaded.

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

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

The description includes the model name, return fields, and usage context, compensating for the lack of output schema. However, it does not mention pagination or sorting behavior, though the limit parameter in schema covers basic pagination.

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

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

Schema coverage is 100% with descriptions for all 6 parameters. The tool description does not add additional input parameter details beyond what the schema provides; it focuses on return values. 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 'List Odoo CRM leads & opportunities', specifying the verb 'List' and resource 'CRM leads & opportunities', and mentions the model crm.lead. It also lists returned fields, distinguishing it from siblings like odoo_list_invoices or odoo_list_sale_orders.

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 usage hint ('Use for "open opportunities" or "sales pipeline"'), giving clear context. However, it does not explicitly state when not to use the tool or name alternative tools, which would warrant a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, idempotent read operation. The description adds context about returned fields and filters but does not disclose additional behavioral traits (e.g., pagination behavior, rate limits). With strong annotations, the description provides moderate added value.

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

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

The description is two sentences, front-loading the core purpose and listing key details. Every word adds value without redundancy or fluff.

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

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

For a read-only list tool with well-documented parameters and annotations, the description covers purpose, returned fields, and usage context. It lacks details on pagination beyond 'limit' and does not mention result format, but these are either in schema or implied. Overall, it is sufficiently complete for correct tool invocation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description does not add substantial semantic meaning beyond what schema descriptions provide (e.g., filter by state). The mention of 'payment_state' in returned fields could clarify the output but does not enhance parameter understanding. 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 specifies the tool lists Odoo customer invoices, identifies the model (account.move) and filter (move_type=out_invoice), lists returned fields, and gives concrete use cases. It effectively distinguishes from sibling tools like odoo_list_sale_orders by being invoice-specific.

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

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

The description provides explicit usage scenarios ('unpaid invoices', 'recent customer invoices'), guiding the agent when to invoke this tool. It does not explicitly state when not to use it or mention alternatives, but the use cases are clear and contextually sufficient given the sibling tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, indicating a safe, read-only, idempotent operation. The description adds behavioral context by specifying the returned fields and the optional state filter. It does not contradict annotations.

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

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

The description is two sentences long, front-loaded with the core action and resource, then specifies return fields and an optional filter, and ends with concrete use case examples. Every sentence adds value with no redundancy.

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

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

For a list tool with 6 parameters, no output schema, and full schema descriptions, the description covers return fields and filtering adequately. It does not mention pagination details (default limit of 20) or error handling, but these are covered in the schema. Overall, it is sufficiently complete given the tool's simplicity.

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?

Input schema has 100% coverage for all 6 parameters with descriptions. The description reinforces the state filter and adds meaning by listing the returned fields (name, customer, amount_total, state, date_order), which are not in the schema. This enriches understanding beyond the schema.

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

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

The description clearly states the verb 'List' and the resource 'Odoo sales orders / quotations (sale.order)'. It specifies the returned fields (name, customer, amount_total, etc.) and lists example use cases like 'recent sales orders' or 'open quotations', distinguishing it from sibling tools like odoo_list_invoices and odoo_list_crm_leads.

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

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

The description provides explicit use case examples: 'Use for "recent sales orders" or "open quotations".' This gives clear context for when to use the tool. However, it does not explicitly mention when not to use it or compare to alternatives, but the context suffices.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior. The description adds context about domain syntax and that it's a 'power-user generic query,' but does not disclose additional behavioral traits like pagination, error handling, or performance implications beyond the annotations.

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

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

Two sentences efficiently front-load the purpose and provide key usage instructions without extraneous detail. Every sentence earns its place.

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

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

Despite high complexity (10 parameters, generic tool) and no output schema, the description does not explain the return format, error handling, or behavior for edge cases. It leaves agents without a clear picture of what to expect from the tool.

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

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

Schema coverage is 100% so baseline is 3. The description provides helpful examples and reinforces domain format, but does not add significant new semantic meaning beyond what the schema already provides.

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

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

The description clearly states the tool runs search_read on ANY Odoo model, provides examples of model names and domain format, and explicitly distinguishes from sibling tools by advising to use it when no specific tool above fits.

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

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

Explicit guidance to use when no specific tool fits, with examples showing typical usage. Lacks explicit instructions on when to avoid or alternative tools beyond siblings, but the fallback nature is well communicated.

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

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

Annotations already mark the tool as read-only, open-world, idempotent, and non-destructive. The description adds value by revealing the case-insensitive substring match (ilike) behavior and the specific fields returned, which goes beyond the annotations.

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

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

The description is extremely concise—two sentences that front-load the purpose and usage. Every word earns its place with no redundancy or 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?

Given 8 parameters, full schema coverage, and annotations, the description is largely complete. It mentions the main search fields and returned data. Minor omissions like explicit mention of default limit (though schema covers it) and result format do not detract significantly.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. However, the description adds examples and clarifies the case-insensitive substring semantics, which provides additional meaning beyond the raw schema.

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

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

The description clearly states the tool searches for Odoo contacts and companies (res.partner) by name, email, or company flag. It specifies the return fields and provides explicit use cases like 'find the contact/customer named X' or 'list companies', distinguishing it from sibling tools such as odoo_list_crm_leads.

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

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

The description gives explicit usage scenarios for finding contacts or listing companies. While it does not explicitly state when not to use this tool, the sibling tools are distinct enough (e.g., listing leads, invoices) that the context is clear.

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

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

Annotations provide only generic hints (readOnlyHint: false, etc.), but the description adds substantial behavioral context: rate-limiting ('Rate-limited to 5 per identifier per day'), cost ('Free; doesn't count against your tool-call quota'), the claim_token mechanism for later follow-up, and the team's daily digest process. It also clarifies that reporting cross-server issues is futile, which helps set expectations. 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 information-dense yet well-structured: it opens with purpose, moves to use cases, exclusions, formatting advice, token mechanics, and side effects. Every sentence adds value, with no fluff or repetition. The length is justified by the breadth of operational guidance provided.

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 low-complexity feedback tool with no output schema, the description covers all necessary context: when to use, what to include, rate limits, quota, token follow-up, and the fact that feedback influences roadmap. There is no missing critical information for the agent to decide, invoke, and interpret results 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 explains each parameter thoroughly (e.g., claim_token: 'Read the reply to a report you filed earlier...'). The description reaffirms the claim_token usage but does not significantly augment the parameter meanings beyond what the schema provides. Since the schema carries the full burden, a baseline 3 is appropriate.

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

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

The description clearly states the tool's function: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It uses a specific verb+resource and is distinguishable from sibling tools like ask_pipeworx (which answers questions) and discover_tools (which lists tools), making its purpose unambiguous.

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

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

Provides explicit when-to-use criteria ('Use when a tool returns wrong/stale data...'), when-not-to-use exclusions ('ONLY for tools served by this Pipeworx connection... file it with that server instead'), and even guidance on what to include ('Describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt'). This is exemplary 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 cover read-only/idempotent/open-world. Description adds value: derives from CF analytics-engine, no PII, caching 5min-1h. 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?

Three sentences plus bullet-point use cases. Front-loaded with core functionality. Every sentence adds information; no fluff.

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

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

Single optional param, no output schema needed. Description fully covers what it returns, use cases, data source, caching, and privacy. No gaps.

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

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

Schema coverage 100% with enum and description. Description adds explanatory context on window choice (hot vs steady-state), enhancing beyond schema.

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

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

Clearly states it returns top tools, packs, and call volume over a window, with three explicit use cases that differentiate it from sibling tools like ask_pipeworx or deep_research.

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

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

Lists specific scenarios for use (discovering hot data, confirming canonical tools, aligning use case). 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?

The description adds substantial behavioral context beyond annotations: it explains scan types, SEMANTIC ANCHOR constraints, PARTITION FILTER, FILL CHECK with live CLOB depth, and the output structure. Annotations indicate readOnly, openWorld, idempotent, and non-destructive, which are consistent with the described behavior. 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 well-structured with clear sections for each mode and details like fill check. It is front-loaded with the core purpose. While lengthy, every sentence earns its place given the tool's complexity. Minor redundancy (e.g., fill check vs custom sizing reference) is acceptable.

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

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

Given no output schema, the description fully explains the return structure (opportunities[], partition_check, fill check results) and edge cases (skipped_low_similarity, placeholders_filtered). With two optional parameters and no required inputs, the description covers all necessary context for an agent 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?

Schema description coverage is 100% with basic descriptions. The tool description enriches parameter semantics by providing examples (e.g., 'fed-decision-may-2026' for event, 'Strait of Hormuz traffic returns to normal' for topic), explaining how each parameter is used, and clarifying that full URLs are accepted for event. This adds value beyond the schema.

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

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

The description clearly states the tool finds arbitrage opportunities via monotonicity violations and partition-sum checks. It distinguishes three modes (no args, event, topic) with specific examples, and the name and title align well with the purpose. Sibling tools like polymarket_edges and polymarket_fill_risk are distinct, and the description avoids ambiguity.

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 with NO args for a trending_scan', 'event (recommended for a specific market)', 'topic (for cross-event scanning)'. It explains why to choose each mode, when not to trade (fill check condition), and even references custom sizing via polymarket_fill_risk. This is comprehensive and actionable.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds significant behavioral context: caching behavior ('Cached 1h at the KV level keyed on all knobs'), diagnostic responses that explain empty segments, edge calculation details, and the presence of warnings like 'Market moved X.Xpp in 24h'. 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 extremely detailed but overly long, making it hard for an agent to quickly parse. It front-loads purpose, but then immediately dives into technical model-family details before covering parameters. A more concise summary at the top followed by structured details would improve conciseness while preserving completeness.

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

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

Despite having no output schema, the description thoroughly documents the return structure: top-level sections (by_segment, fed_candidates, _diagnostics), per-opportunity fields (edge_pp_net, kelly_fraction, etc.), and even explains why certain segments might be empty. It covers all 9 parameters with detailed explanations. Given the tool's complexity, this is a complete and highly informative description.

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?

Input schema has 100% coverage, so baseline is 3. The description adds value beyond the schema by explaining how parameters interact (e.g., 'min_kelly never filters them — this knob applies to the per-leg Kelly'), providing usage guidance for each parameter (e.g., 'Set to 5000 to drop thin-book opportunities'), and clarifying defaults and edge cases. This lifts the score above baseline.

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

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

The description starts with a clear verb+resource: 'Scan top Polymarket markets and return opportunities...' and specifies the tool's unique differentiation: 'where Pipeworx data disagrees with market price.' It explicitly states its intended use case: 'Built for "what should I bet on today".' Given the many sibling tools (e.g., polymarket_arbitrage, polymarket_edge_tracker), this description effectively distinguishes the tool's scope.

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 strong context for when to use the tool: for discovering betting opportunities daily. It details 'tradeable-edge knobs' and explains how to filter results. However, it does not explicitly contrast with sibling tools or state when NOT to use it. The presence of sibling tools like 'polymarket_arbitrage' suggests overlapping functionality, and explicit exclusions 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 declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds valuable behavioral details beyond annotations: snapshot TTL (60 days), decay computation from daily closes (not intraday), and the structure of the response (tracked, expired, snapshot_dates). 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 informative and front-loaded with the core question. It uses clear structure (RESPONSE sections) and every sentence adds unique value. Slightly dense but justified by the complexity of the telemetry data provided.

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

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

No output schema exists, so the description fully explains return fields: tracked[], expired[], snapshot_dates[]. It also covers limits (60-day TTL, daily closes). For a tool with two optional parameters and no output schema, the description is comprehensive and leaves no critical gaps.

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

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

Schema coverage is 100% with both parameters described. The description reinforces parameter roles (lookback days, window family) and adds context about defaults and limits (days default 14, clamp 2-30; window options). Slight redundancy but adds clarity 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 identifies the tool's purpose: providing edge persistence and decay telemetry from daily snapshots. It answers specific questions about edge longevity and trend, and distinguishes itself from the sibling 'polymarket_edges' tool by focusing on time-series analysis rather than raw snapshot data.

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

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

The description implicitly guides usage by contrasting fresh vs. old edges and mentioning that a three-week-old wide edge is different. It doesn't explicitly list alternatives or when-not-to-use scenarios, but the context is sufficient for an agent to select this tool for edge persistence analysis.

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

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

The annotations are all benign (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false), and the description goes far beyond them by detailing the tool's behavior: walks the order-book ladder, computes VWAP and slippage, returns a verdict, and warns about thin books and forced directional risk. No contradiction with annotations.

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

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

The description is well-structured with clear labels (SINGLE-MARKET, BASKET) and uses all-caps for key guidance. It is relatively long, but every sentence provides valuable information. A minor improvement would be trimming redundant phrases, but overall it is efficient for the complexity of the 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 that there is no output schema, the description fully compensates by listing all return fields for both modes, including warnings about thin legs, forced directional risk, and the verdict categories. The description also covers the selection logic between modes and important edge cases (clamp on size_usd, default behavior). It is complete for the tool's domain.

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

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

Schema coverage is 100%, so the baseline is 3. However, the description adds significant context beyond the schema: it explains how size_usd is interpreted differently for single-market (max spend or target proceeds) vs basket (settlement notional, shares per leg), and how the side parameter defaults to 'auto' in basket mode based on partition sum. This additional semantic detail justifies a 4.

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

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

The description starts with a clear, specific verb-resource pair: 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It explicitly distinguishes two modes (single-market and basket) and lists the return fields for each, making the purpose unmistakable. The sibling tools list includes polymarket_arbitrage and polymarket_edges, and the description directly states it should be used before acting on those signals, differentiating 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: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It also explains when not to use it implicitly by specifying the trade size threshold and outlines the risk of partial basket fills converting an arb into an unhedged directional position. The required parameter modes are clearly stated.

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

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

Despite annotations already indicating read-only and idempotent, the description adds extensive behavioral details: safety fields, compatibility_warning conditions, temporal alignment, skipped cross types/subtypes, and what the tool says when bet shapes are not equivalent. Highly transparent.

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 informative; however, it contains some redundancy and could be more concise. It is front-loaded with purpose, which is good, but the density of details lowers conciseness.

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

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

For a complex tool with 3 parameters and no output schema, the description is remarkably complete: it explains the response structure, safety fields, warnings, temporal alignment, and the meaning of compatibility flags. No gaps.

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

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

Schema coverage is 100% with descriptions for each parameter, but the tool description adds extra context on how the two modes work and the topic list values, enhancing 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 it computes cross-venue spread between Kalshi and Polymarket for the same resolving question, distinguishing two modes and explaining the output. It is distinct from sibling tools like polymarket_arbitrage.

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

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

Describes when to use (for comparing prices across venues), provides two clear modes, and warns that most shortcut topics return compatibility warnings implying limited tradeability. Could be more explicit about alternatives or when not to use, but the guidance is solid.

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

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

Annotations already declare readOnlyHint and idempotentHint. Description adds that it is scoped to identifier and that omitting key lists all keys. No contradiction; additional context provided.

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 key action and dual behavior. Every sentence adds value with no redundancy.

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

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

Covers purpose, usage, scoping, and pairing with other tools. Missing return format, but tool is simple and output is likely a value or list. Minor gap given low complexity.

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

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

Schema coverage 100% but description adds meaning: parameter key controls whether to retrieve a specific value or list all keys. This goes beyond schema description.

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

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

Description clearly states the tool retrieves a value by key or lists all keys when omitted. It uses specific verbs (retrieve/list) and identifies the resource (memory saved via remember). Distinguishes from siblings remember and forget.

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

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

Explicitly says when to use: to look up context saved earlier, avoiding re-derivation. Mentions scoping and pairing with remember/forget. Does not state when not to use or mention 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?

Annotations already declare safe read-only behavior (readOnlyHint, non-destructive). The description adds valuable context: mark_read flags events read affecting next call, polling is supported, and the same feed is available via GET endpoint. 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: first introduces purpose and returned fields, second explains filtering, third covers mark_read and alternative access. Every sentence earns its place, 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?

Despite no output schema, the description specifies return fields (source, citation_uri, payload) and covers filtering, mark_read, unread_only, and polling. Lacks explicit limit defaults but schema provides that. Missing error handling context but adequate for the tool's simplicity.

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

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

Schema covers all 5 parameters with descriptions. The description enriches by giving a concrete example for type ('sec_8k') and explaining mark_read's effect on future calls. This adds practical nuance 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 pulls fired events from the subscription feed and returns recent alerts with key fields. It distinguishes itself from siblings like list_subscriptions and recent_changes by focusing on alerts and mentioning an alternative REST endpoint for scripts/dashboards.

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 filtering options (type, since) and explains the mark_read behavior for subsequent calls. It also notes that polling works fine and gives an alternative access method, but does not explicitly contrast with sibling tools like recent_changes.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds internal fan-out details (SEC EDGAR, GDELT→GNews, USPTO soft-fail) and output structure (changes grouped by source, total_changes, citations). However, it does not disclose potential limits like maximum window or API rate 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 comprehensive but slightly lengthy. It is well-structured: front-loaded with example queries, then sources, then parameter details, then guidance. While every sentence adds value, a more streamlined version could be more concise.

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

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

Given the tool's complexity (multiple data sources, fallback, parameter flexibility, no output schema), the description is complete. It explains all major behaviors, input formats, and even the output structure (changes grouped by source, total_changes, pipeworx:// URIs).

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 significant value: explains that 'type' only supports 'company', describes 'since' format with examples and typical usage ('30d' or '1m'), and clarifies 'value' accepts ticker or zero-padded CIK. This goes well beyond the schema descriptions.

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

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

The description defines a specific verb-resource combination: 'change feed for a company in the last N days/weeks/months'. It clearly distinguishes from the sibling tool 'entity_profile' by explicitly saying 'Use entity_profile instead when you want the static 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?

Provides explicit when-to-use guidance: 'Use entity_profile instead when you want the static profile...'. Includes example queries, explains fallback behavior (GDELT preferred, GNews when rate-limited), and suggests typical monitoring window ('30d' or '1m').

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 idempotentHint=true and destructiveHint=false. Description adds behavioral context: memory is scoped by identifier, persistent for authenticated users, 24-hour retention for anonymous sessions. 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?

Three sentences, no wasted words. Front-loaded with purpose, then usage, then technical details. Every sentence is substantive.

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 key-value write tool with no output schema, the description covers purpose, usage, persistence, pairing, and parameter conventions. Fully adequate for an agent to use correctly.

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

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

Schema coverage is 100%, but description adds value by providing key naming conventions (e.g., 'subject_property', 'target_ticker') and clarifying value is 'any text — findings, addresses, preferences, notes', which goes beyond schema definitions.

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

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

Description starts with a clear verb ('Save data') and resource ('data the agent will need to reuse later'). It provides concrete examples of what to store (resolved ticker, target address, user preference) and explicitly pairs with recall and forget, distinguishing it from siblings.

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

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

Description explicitly states when to use ('when you discover something worth carrying forward') and pairs with recall/forget for lifecycle management. It does not explicitly state when not to use or provide alternatives, but the context is clear enough.

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

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

Beyond the readOnly and idempotent annotations, the description discloses graceful degradation when GLEIF/OpenFIGI are unavailable, and explains that unresolved identifiers are listed under an `unresolved` field rather than omitted. It also reveals internal cascading lookups, which helps set expectations about latency.

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 lengthy but structured, with examples, supported types, and fallback behavior. It is front-loaded with usage examples and does not waste space, though a more concise version would be easier to parse.

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 compensates by detailing the output identifiers, source attribution, unresolved handling, and degradation behavior. This gives the agent a full mental model of what to expect, making it complete for a lookup tool.

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

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

The schema already fully documents both parameters, so the baseline is 3. The description adds value by explaining what each entity type resolves to (e.g., CIK/LEI/FIGI for companies, RxCUI for drugs) and how inputs are interpreted, though it partially repeats the schema's input examples.

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

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

The description clearly states the tool resolves user-spoken names to canonical identifiers, with a specific verb and resource. It distinguishes itself from siblings by noting that other tools require these identifiers as input, and includes concrete query examples.

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

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

It explicitly instructs to 'Use FIRST whenever you have a name but need an ID,' providing a clear when-to-use rule. It also contrasts with manual multi-step lookups, implying it replaces them, though it doesn't name specific alternative tools.

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

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

Annotations already indicate read-only, open-world, idempotent, and non-destructive behavior. The description adds valuable detail: it probes each entity with ai_visibility_check, ranks by score, and returns score, confidence, and signal density. 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 three sentences, front-loaded with the main action, then elaborates on method and use case. Every sentence adds value with no redundancy.

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

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

The description covers what the tool does, how it works (probing with ai_visibility_check), what it returns (ranked list with scores), and parameter details. Given that annotations handle safety and idempotency, no further behavioral context is needed.

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

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

Although schema coverage is 100%, the description adds critical meaning: it specifies that entities must be 2-8 and the first is treated as the subject; it lists supported models and notes that 'workers-ai' is the default; it explains that context disambiguates common names. This goes well 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: compare AI visibility across multiple entities side-by-side, using ai_visibility_check, and ranks results. It distinguishes from sibling 'compare_entities' by specifying the method and output (ranked list with scores).

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) and context (e.g., 'does Claude know about us as well as our competitors?'). It implicitly suggests using ai_visibility_check for single entities but does not explicitly state when not to use this tool or list 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?

Adds rich behavioral context beyond annotations: describes partial failures, bundlephobia's 5-30s measurement delay, and that sources_failed will list timeouts. Annotations already declare read-only and idempotent, but description elaborates on the multi-source fan-out and graceful degradation.

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

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

The description is informative and front-loaded with purpose, but it is somewhat lengthy. Every sentence adds value, though a bit more conciseness would improve it. Overall 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?

Despite lacking an output schema, the description fully explains the return content (summary block, per-advisory detail, links, alternatives), ecosystem scope, fallback behavior, and error handling. It covers all necessary context for an agent to use the tool correctly.

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

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

Schema coverage is 100% with both parameters described. Description adds the note that scoped packages (e.g. @types/node) are accepted and that version defaults to latest, but this is minor enhancement. The schema already provides sufficient semantics.

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

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

The description clearly states it's a composite check for npm packages covering license, advisories, version history, and bundle size. It uses specific verbs like 'fans out across deps.dev and bundlephobia' and distinguishes from sibling tools by targeting npm dependency 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?

Explicit guidance: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"'. It also specifies the NPM ecosystem limitation and directs users to deps.dev:version for other ecosystems.

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

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

Annotations already indicate read-only, open-world, idempotent, and non-destructive behavior. The description adds valuable technical details: BGE-base-en embeddings, cosine similarity, 500-char overlapping windows, 200K char cap with truncation flagging, and character offsets in results. No contradictions.

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

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

The description is a single paragraph that efficiently front-loads the main purpose, then covers usage context, technical details, and pairing advice. Every sentence is necessary and 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?

Without an output schema, the description adequately outlines return content (top-N passages, offsets, similarity scores) and explains truncation behavior. It also addresses pairing with a sibling tool. Minor omission: no mention of error handling or pagination, but these are not critical for a search 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 all 3 parameters with descriptions (100% coverage). The description adds extra value by providing example queries for the query parameter, stating the default for limit, and clarifying the 200K char constraint for text. Baseline is 3; the additional context justifies a 4.

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

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

The description clearly states it performs semantic search inside a fetched record, provides concrete examples (SEC 10-K, article), and distinguishes itself from the sibling tool ask_pipeworx_grounded by explaining how they pair together.

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 advises use when the record is too large for the prompt and explains the benefits. It also suggests pairing with ask_pipeworx_grounded. While it doesn't list explicit when-not-to-use scenarios, the condition is clearly implied.

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

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

Annotations already indicate readOnlyHint=false, idempotentHint=true, destructiveHint=false. The description adds valuable context: OAuth requirement, rate limits (10/day SMS cap), webhook secret returned only once, and that subscriptions persist. It does not contradict 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 and front-loaded. Every sentence provides necessary information. Could be slightly more concise, but cuts are not obvious.

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

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

Given the complexity (3 params, nested objects, enums, no output schema), the description is comprehensive. It covers all types, param formats, delivery details, OAuth requirement, return value, and rate limits.

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

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

Schema coverage is 100%, but the description adds significant meaning beyond schema. It explains each enum value (e.g., 'sec_8k' = 8-K filings with ticker+item codes), gives detailed param examples, and specifies delivery constraints (e.g., SMS requires verified phone).

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 'Create a proactive monitoring subscription to a live-data event stream. Returns the new subscription id.' This is a specific verb and resource, and it distinguishes from sibling tools like list_subscriptions, unsubscribe, and recent_alerts.

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

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

The description includes explicit requirements ('Requires a Pipeworx OAuth account (anonymous + BYO cannot persist subscriptions)') and provides guidance on when to use each subscription type and delivery channel. It does not need to state when-not-to-use explicitly.

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

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

Annotations already provide readOnlyHint=true, openWorldHint=true, etc. Description adds behavioral context: it's an onboarding tool, returns example questions, no arguments for full spread, and does not modify anything. No contradictions.

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

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

Description is front-loaded with synonyms and purpose, but somewhat lengthy. Every sentence adds value; could be slightly tighter but well-structured overall.

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

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

Given no output schema, description fully explains return format (category-bucketed example questions with tool+argument shape). It adequately covers usage, parameter, and behavioral aspects. Sibling tools are diverse but description clearly positions this tool as the onboarding entry point.

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

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

Only one optional parameter 'topic' with enumerated examples in the description (e.g., 'finance', 'pharma'). Schema coverage is 100%. Description adds meaning by listing example values and stating 'Omit for a cross-category spread.'

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

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

The description clearly states the tool returns category-bucketed example questions with tool/invocation details, serving as an onboarding entry point. It uses specific verbs ('returns', 'call') and resource ('example questions') and distinguishes from siblings by positioning as a first-use 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?

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' Also provides guidance on optional topic parameter. Alternatives are not named but implied from the sibling list and meta-tool reference.

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

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

Adds behavioral detail beyond annotations: ownership check, deactivation rather than deletion, and historical data preserved. Aligns with idempotentHint=true and destructiveHint=false. No contradiction.

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

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

Two sentences, front-loaded with purpose. Every sentence adds unique value (ownership, deactivation, historical data). No wasted words.

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

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

Complete for a simple tool with 1 parameter and no output schema. Covers purpose, ownership, effect, and links to recent_alerts for historical 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 covers 100% of parameters with description for 'id'. Description does not add parameter-specific meaning beyond schema, but no gap exists. Baseline 3 is appropriate.

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

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

Describes specific verb 'Cancel' and resource 'subscription by id'. Clearly distinguishes from sibling tools like 'subscribe' and 'list_subscriptions' by mentioning ownership enforcement and deactivation behavior.

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

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

States ownership enforcement ('only cancel your own subscriptions'), which provides clear when-to-use guidance. Implicitly excludes canceling others' subscriptions. Lacks explicit 'when not to use' but adequate.

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

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

Annotations already signal read-only, idempotent, and non-destructive behavior, so the description adds high-value semantics: it enumerates the six verdicts and crucially explains that 'could_not_verify' is a failure state, not evidence, and 'unsupported' means no source was found. This prevents callers from misinterpreting results, going well beyond structured annotations.

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

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

The description is lengthy but well-organized: it opens with the tool's core purpose and usage, then details return values and critical caveats. The 'replaces 4–6 sequential calls' note is slightly ancillary but still useful for understanding value. Every major sentence carries necessary information, though it could be tightened.

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 lacking an output schema, the description fully specifies what the tool returns (verdict, actual value, citation, reasoning) and clarifies ambiguous outcomes (could_not_verify vs. unsupported). It also describes the two routing paths and error conditions, making it complete for an agent to decide when and how to invoke the tool.

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

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

Schema coverage is 100%, so both parameters are already documented. The description adds meaningful context for tolerance_pct by explaining it overrides the claim's implied tolerance and is intended for hallucination detection (1–2%), and it frames the claim parameter with realistic examples. This elevates it above the baseline 3.

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

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

The description clearly identifies validate_claim as a natural-language claim verification tool against authoritative sources, with specific trigger phrases and two execution paths (SEC EDGAR fast path vs. grounded pipeline). It distinguishes itself from sibling tools by positioning it as a single call that replaces 4–6 sequential steps, making its purpose unambiguous.

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

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

The description explicitly states 'Use whenever the agent needs to check whether something a user said is factually correct,' giving a clear when-to-use rule. It also explains internal routing for company-financial vs. other claims, providing useful context. However, it does not name alternative tools or state when not to use it, so it lacks explicit exclusions.

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