launches

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

Annotations already indicate readOnlyHint, idempotentHint, and destructiveHint=false. The description adds value by explaining the scoring mechanism (0-100), return structure (per-model {score, confidence, signals, raw_response} + combined), and that the default model is free while Anthropic requires a private API key. No contradictions.

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

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

The description is concise with four well-structured sentences: core function, default/optional config, return structure, and use cases. No redundant or filler content.

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

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

For a tool with no output schema, the description covers the key return fields. It also explains parameters and use cases comprehensively. Minor omission: no mention of error handling or rate limits, but acceptable given the 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?

All four parameters have full schema descriptions (100% coverage), and the tool description enriches them with additional context: the 'entity' parameter gets examples, 'models' explains default vs optional, '_apiKey' details BYO key usage, and 'context' provides a disambiguation example. 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 defines the tool's function: probing LLMs to score AI visibility. It uses a specific verb ('probe') and resource ('LLMs for what they know about a business/brand/product/topic'), and lists concrete use cases (AI-marketing audits, pre-launch brand checks, competitive monitoring), making it easily distinguishable from siblings.

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

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

The description explains when to use each model (default Workers AI, optional Anthropic with BYO key) and lists relevant use cases. However, it does not explicitly exclude situations or differentiate from the sibling tool 'scan_competitor_ai_presence'.

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

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

With no annotations provided, the description carries full burden. It discloses key behavioral traits: the tool automatically selects data sources and fills arguments, handles natural language questions, and returns results. It doesn't mention limitations like rate limits, authentication needs, or error conditions, but provides substantial operational context beyond basic purpose.

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 efficiently structured: first sentence states core purpose, second explains the mechanism, third provides usage guidance, and final sentence offers concrete examples. Every sentence adds value with zero redundant information, making it easy to parse and understand quickly.

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 (natural language processing with automatic tool selection) and lack of annotations/output schema, the description provides strong context about what the tool does and how to use it. It could benefit from mentioning response format or error handling, but the examples help illustrate expected usage patterns adequately.

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

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

Schema description coverage is 100% with one parameter ('question') well-documented in the schema. The description adds minimal parameter semantics beyond the schema, only reinforcing that questions should be 'in plain English' or 'natural language.' This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Ask a question in plain English and get an answer from the best available data source.' It specifies the verb ('ask'), resource ('answer'), and mechanism ('Pipeworx picks the right tool, fills the arguments'). It distinguishes from siblings by emphasizing natural language input versus structured tool selection.

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: 'No need to browse tools or learn schemas — just describe what you need.' It contrasts with sibling tools that likely require specific parameters or tool knowledge, providing clear guidance on using this as a high-level query interface versus lower-level tool invocation.

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 details the tool's behavior beyond annotations: it performs an extra LLM call, returns explicit refusal on failure, and specifies the response structure with fields like evidence and confidence. No contradictions 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 well-structured with important information front-loaded. Each sentence adds value, though it is somewhat lengthy. Could be slightly more concise without losing clarity.

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

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

Given the tool's complexity (refusal modes, extra LLM call, response structure), the description covers all necessary aspects for an agent to use it correctly. No output schema exists, but the description compensates fully.

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 only restates that the 'question' parameter accepts multiple aliases, which is already in the schema. It adds no additional semantic meaning or guidance for each parameter.

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

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

The description clearly defines the tool as a 'hallucination-resistant answer mode for high-stakes reads' and specifies that it extracts answers only from tool results. It distinguishes itself from the sibling tool 'ask_pipeworx' by noting the extra LLM call cost and appropriate use cases.

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 (when answers will be quoted, cited, or acted on, and invention is unacceptable) and when to prefer the sibling (casual lookups). It also lists refusal reasons for clarity.

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

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

Annotations (readOnlyHint, idempotentHint, etc.) indicate safe read-only behavior. The description adds extensive behavioral details: market resolution, classification, parallel fan-out, low-confidence handling, closed market handling, wide spread warnings, safety mechanisms (short-circuit on low confidence). 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 long and detailed, but appropriately structured with sections (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES). It front-loads the core purpose. Minor verbosity in the fan-out examples, but for a complex tool, this level of detail is justified. Could be slightly more concise.

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

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

Given there is no output schema, the description thoroughly covers the return structure: market fields, analysis (model probability, edge), evidence, resolver contract, parent event, news fields. It also addresses edge cases (low-confidence, closed markets, wide spreads) and safety mechanisms. Highly complete for a complex research tool.

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

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

Schema coverage is 100% with all three parameters described. The description adds context beyond the schema: for 'market' it explains it can be slug, URL, or question text; for 'depth' it clarifies quick vs thorough; for 'include_raw' it explains default behavior and when to use true. This adds significant value over the schema alone.

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

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

The description clearly states the tool's purpose: researching a Polymarket bet by pulling Pipeworx data in one call. It specifies inputs (slug, URL, question text) and what it returns, and distinguishes itself from siblings like polymarket_edges by being a comprehensive research tool. The usage examples ('should I bet on X') further clarify purpose.

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

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

The description provides explicit usage suggestions ('Use for...') and classifiers, but it does not explicitly state when not to use this tool versus alternatives. It implies broad applicability but lacks exclusion criteria. Given the context of sibling tools, this is a minor gap.

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

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

Despite having no annotations, the description discloses the type-specific data returned (revenue, net income, etc. for companies; adverse-event counts, FDA approvals, etc. for drugs) and mentions the output includes paired data and resource URIs. It does not contradict the input schema.

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

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

The description is extremely concise, using two well-structured sentences. The main purpose is front-loaded, and every sentence adds value without redundancy.

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

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

For a tool with two simple parameters and no output schema, the description explains the entity types, data fields, and efficiency benefit. It could be more specific about the exact format of 'paired data', but it is largely 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?

The input schema already has 100% descriptive coverage for both parameters. The description restates the parameter constraints without adding new semantics beyond what the schema provides, so the baseline score of 3 applies.

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

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

The description clearly states the tool compares 2–5 entities side by side in one call, specifying two entity types and the data fields returned for each. It also highlights that it replaces 8–15 sequential calls, distinguishing it from other tools on the server.

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 clear usage context: use this tool to compare multiple entities efficiently instead of making many separate calls. However, it does not explicitly mention when not to use it or compare it to specific 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?

No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: it's a search operation that returns relevant tools with names and descriptions, and it's intended for initial discovery. However, it lacks details on rate limits, error handling, or response format, which are important for a tool with no output schema.

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

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

The description is appropriately sized and front-loaded, with two sentences that efficiently convey purpose and usage guidelines without wasted words. Every sentence adds clear value, making it highly concise and well-structured.

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

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

Given the tool's complexity (a search tool with 2 parameters, no output schema, and no annotations), the description is mostly complete. It covers purpose and usage well but lacks details on behavioral aspects like response format or limitations, which would be helpful since there's no output schema. It's adequate but has minor gaps.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (query and limit) thoroughly. The description does not add any parameter-specific information beyond what's in the schema, such as examples or constraints not covered. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('search', 'returns') and resource ('Pipeworx tool catalog'), and explicitly distinguishes it from sibling tools by emphasizing its role in finding tools among 500+ available options, which is distinct from the launch-related siblings listed.

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 guidelines: 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This clearly indicates when to use it (as an initial step for tool discovery in large catalogs) and implicitly suggests alternatives (sibling tools like search_launches for more specific queries) by context.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds context about fan-out across multiple APIs, USPTO sunset and soft-fail, GDELT→GNews fallback, and return structure. Minor gap: no mention of rate limits or data staleness beyond 'latest 10-K'.

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 dense paragraph; the first sentence loads the use case examples clearly. It is informative but slightly long—could benefit from bullet points for readability, but not a major flaw.

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 thoroughly explains return components (cik, company_name, recent_filings with URIs, fundamentals, patents, news, LEI) and data sources. It even notes USPTO sunset and fallback behavior, achieving high completeness.

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

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

Schema coverage is 100%, and the description reinforces parameter usage with an example ('AAPL' or '0000320193') and explicitly states names are not supported. This adds value beyond the schema's enum and type.

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 explicit trigger phrases ('Tell me about X', 'research Acme') and states 'full cross-source profile of a US public company in ONE parallel call.' It clearly distinguishes from chaining single-pack lookups, 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?

It explicitly says 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view,' and provides clear when-to-use and when-not-to-use guidance (names not supported, suggesting resolve_entity first).

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a deletion operation, which implies destructive behavior, but doesn't specify whether deletion is permanent, reversible, requires specific permissions, or has side effects. For a destructive tool with zero annotation coverage, this is insufficient.

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, efficient sentence with zero waste. It's appropriately sized for a simple tool and front-loads the essential information (delete operation).

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 destructive operation with no annotations and no output schema, the description is incomplete. It doesn't explain what happens after deletion (success confirmation, error handling), whether there are constraints on deletable memories, or how this tool relates to sibling memory tools. The minimal description leaves significant gaps.

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

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

Schema description coverage is 100%, so the schema already documents the single 'key' parameter. The description adds minimal value by restating 'by key' but doesn't provide additional context about key format, validation, or examples beyond what the schema 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 action ('Delete') and resource ('a stored memory by key'), making the tool's purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'recall' or 'remember' which likely interact with the same memory system, so it doesn't reach the highest score.

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 no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, when deletion is appropriate, or what happens to deleted memories. Given sibling tools like 'recall' and 'remember', some context about usage distinctions would be helpful.

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. The description adds behavioral details such as 'Fetches the page, extracts title/description/key links' which implies a network fetch and transformation. This provides context beyond annotations without contradiction.

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

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

The description consists of two efficient sentences. First sentence states the core purpose and target, second provides details and use cases. No superfluous content; key information is front-loaded.

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

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

For a simple tool with complete schema and annotations, the description covers output format ('standard llms.txt markdown format'), output location ('site-root/llms.txt'), and multiple use cases. No output schema exists, but the description adequately explains return value as a text blob.

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% description coverage, so parameters are well-documented. The description adds no additional semantic information beyond what the schema provides, e.g., default value for max_links is already in 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 clearly states the tool generates a production-ready llms.txt file for any URL. It explicitly names the output format and target AI crawlers, distinguishing it from sibling tools like ai_visibility_check by specifying the exact file generation purpose.

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

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

The description provides three concrete use cases (client indexing, own project drafting, competitor auditing) which guide appropriate usage. However, it does not explicitly exclude situations where the tool might not be suitable, nor does it compare to alternatives like ai_visibility_check.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the return data (name, net time, etc.), which adds value beyond the input schema. However, it lacks details on error handling, rate limits, authentication needs, or whether it's a read-only operation, leaving gaps in behavioral context for the agent.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by a concise list of returned data. Every sentence earns its place by providing essential information without redundancy, making it efficient and well-structured for quick understanding.

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 low complexity (1 parameter, no output schema, no annotations), the description is mostly complete. It explains what the tool does and what data it returns, but without an output schema, it could benefit from more detail on the return format or error cases. The lack of annotations means the description should cover more behavioral aspects, which it partially does but not fully.

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 description coverage is 100%, so the input schema already fully documents the 'id' parameter. The description does not add any additional meaning or context beyond what the schema provides, such as examples of valid IDs or usage notes, resulting in a baseline score of 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 states the specific action ('Get full details') and resource ('a specific launch by its Launch Library 2 ID'), and distinguishes it from siblings by focusing on individual launch details rather than lists or searches. It explicitly mentions the data returned, which helps differentiate its purpose from the sibling tools that handle multiple launches.

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

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

The description implies usage context by specifying 'by its Launch Library 2 ID', suggesting this tool is for retrieving details when you have a specific launch ID. However, it does not explicitly state when to use this tool versus alternatives like get_past_launches or search_launches, nor does it provide exclusions or prerequisites, leaving some ambiguity for the agent.

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?

No annotations are provided, so the description carries full burden. It discloses what data is returned (name, net launch time, etc.) but lacks behavioral context like rate limits, authentication needs, pagination behavior, error conditions, or whether this is a read-only operation. The description doesn't contradict annotations (none exist).

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

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

Two concise sentences: one stating the action and source, another listing returned fields. Efficiently front-loaded with core purpose. Could be slightly improved by integrating return details more smoothly.

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 read operation with 1 optional parameter and no output schema, the description is adequate but has gaps. It specifies the data source and return fields, but lacks context on limitations, errors, or sibling tool differentiation. Without annotations or output schema, more behavioral transparency would be beneficial.

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 the 'limit' parameter with its default. The description adds no parameter-specific information beyond what's in the schema. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Get past rocket launches from Launch Library 2' with specific verb+resource. It distinguishes from 'get_upcoming_launches' by specifying 'past' launches, but doesn't explicitly differentiate from 'get_launch' (singular) or 'search_launches'.

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?

No guidance on when to use this tool versus alternatives. The description doesn't mention when to choose this over 'get_launch' (singular), 'get_upcoming_launches', or 'search_launches'. Only implicit context from 'past' in the name.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions the return fields (name, net launch time, etc.) but lacks details on permissions, rate limits, pagination, or error handling. For a read operation with external data, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that front-loads the purpose and key return data. It avoids redundancy but could be slightly more structured by separating usage context from output details.

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 annotations and no output schema, the description provides basic purpose and return fields but misses behavioral aspects like data freshness, source reliability, or error cases. It's adequate for a simple read tool but lacks depth for robust agent use.

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

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

Schema description coverage is 100%, with the single parameter 'limit' documented in the schema. The description adds no parameter-specific information beyond implying a default behavior for upcoming launches, so it meets the baseline of 3 without compensating for any gaps.

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

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

The description clearly states the action ('Get upcoming rocket launches') and the data source ('from Launch Library 2'), distinguishing it from sibling tools like get_past_launches. It specifies the verb (get) and resource (upcoming rocket launches), though it doesn't explicitly contrast with search_launches in scope or method.

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?

No guidance is provided on when to use this tool versus alternatives like get_past_launches or search_launches. The description implies it's for upcoming launches but doesn't specify contexts, exclusions, or prerequisites, leaving usage decisions ambiguous.

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 not destructive. Description adds return field details and optional inactive parameter behavior, adding value beyond annotations.

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

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

Two sentences, front-loaded with purpose, then usage guidance and return fields. 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?

Simple tool with one optional parameter. Description covers return fields and usage. Minor gap: no mention of pagination or ordering, but likely 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% with description for include_inactive. Description mentions 'active subscriptions' but does not add new meaning to the parameter 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 'List the caller's active subscriptions' and lists return fields. It distinguishes from siblings like subscribe/unsubscribe but does not explicitly differentiate.

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

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

Explicit guidance: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' This tells when to use and why.

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

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

With no annotations provided, the description carries the full burden. It discloses the rate limit (5 per day) and provides guidance on what to include (context of tools/data) and what to exclude (end-user prompt verbatim). This gives the agent clear behavioral expectations beyond just 'sending feedback'.

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, each delivering essential information: purpose, use cases, content guidance, and rate limit. No redundant text, and the most critical info (purpose) is first. 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?

Given the tool has 3 parameters (one nested object), no output schema, and no annotations, the description covers usage context, rate limits, and parameter semantics well. It's complete enough for an agent to use correctly, though it could mention if there's a response or confirmation after sending.

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

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

The input schema has 100% description coverage, so the parameters are well-documented. The description adds value by reinforcing that the message should be specific and typical length (1-2 sentences, 2000 chars max) and warns against including the user's prompt verbatim. This goes beyond the schema's field descriptions.

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

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

The description explicitly states 'Send feedback to the Pipeworx team' and lists specific categories (bug, feature, data_gap, praise). This clearly distinguishes it from sibling tools like ask_pipeworx or discover_tools, which have different purposes.

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 says 'Use for bug reports, feature requests, missing data, or praise' and mentions a rate limit of 5 messages per day. However, it does not explicitly state when not to use this tool or recommend alternatives, though the use cases are clear.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable details: caching (5min-1h), data source (CF analytics-engine), privacy (no PII), and output structure (pack, tool, count). This goes well beyond annotations.

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

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

The description is concise, front-loaded with a one-line summary, followed by return type, bullet-pointed use cases, and source/caching details. Every sentence adds value without redundancy.

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

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

For a simple read-only tool with one optional parameter, the description covers purpose, output structure, caching, data source, and privacy. No output schema exists, but the description sufficiently describes the return shape. Annotations handle safety. Complete for the tool's complexity.

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

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

The input schema already has full coverage (100%) with a clear description for the single parameter 'window'. The main description only reiterates the enum values and window context, adding no new semantic information beyond the schema.

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

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

The description clearly states the tool returns top tools, top packs, and total call volume over a recent window. It uses specific verbs ('Returns') and identifies the resource (trending data). The three use cases further clarify its purpose, distinguishing it from sibling tools like discover_tools.

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

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

The description provides clear use cases (discovering hot data, confirming canonical choice, checking alignment) and guidance on window selection (short for hot, long for steady-state). However, it does not explicitly compare with alternatives or state when not to use this tool.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds significant behavioral context: explains the monotonicity and partition-sum checks, details the Jaccard similarity threshold (≥0.30) for cross-event pairs, the partition filter for placeholders, and the response structure including 'partition_check'. 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 quite long (over 200 words) and contains dense technical details. While it is well-structured with sections for modes, filters, and responses, the first sentence in all caps ('REQUIRES one of...') and the lack of whitespace make it less front-loaded and harder to scan quickly. Some redundancy exists (e.g., repeating the response structure).

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

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

Given the tool's complexity (two modes, multiple checks) and the absence of an output schema, the description covers the essential behavioral aspects: input requirements, the two modes with their intended use, key algorithms (monotonicity, partition sum), filters (Jaccard, placeholder), and a summary of the response fields. It provides sufficient context for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100% with descriptions for both parameters. The description enhances understanding by providing examples ('fed-decision-may-2026'), explaining that full Polymarket URLs are accepted for the event parameter, and clarifying that the topic parameter triggers a platform-wide search. This goes beyond the schema's basic descriptions.

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

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

The description clearly states the tool's function: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It details two modes (event and topic) with specific use cases. However, it does not explicitly differentiate from sibling tools like 'polymarket_edges' or 'polymarket_kalshi_spread', though the unique functionality is implied.

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 opens with a clear requirement: 'REQUIRES one of event (single-event mode) OR topic (cross-event mode) — call with no args fails.' It recommends event mode for specific markets and topic mode for cross-event scanning, and notes that cross-event catches patterns single-event misses. No explicit when-not-to-use or alternatives, but the guidance is practical.

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, idempotentHint=true, destructiveHint=false. The description adds extensive detail: caching behavior, knob effects, diagnostic output, slippage handling, and the structure of response segments. 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, front-loading the core purpose and then detailing segments, knobs, and response format. However, it is quite long and could be trimmed slightly for efficiency while retaining clarity.

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

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

Given the tool's complexity (9 parameters, three segments, diagnostic output) and the absence of an output schema, the description covers response top-level fields, diagnostic keys, and caching strategy. It leaves no major gaps for an agent to understand invocation and expected output.

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

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

Schema coverage is 100% with all 9 parameters described. The description provides additional context beyond the schema, such as default values, reasoning for parameter effects (e.g., min_kelly filters out too-small opportunities), and practical advice (e.g., slippage_pp default rationale).

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

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

The description clearly states the tool scans Polymarket markets and returns opportunities where Pipeworx data disagrees with market price. It specifies the three model segments and positions the tool as a daily bet discovery aid, distinct from siblings 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?

The description implies usage for daily opportunity discovery but does not explicitly contrast with alternatives like polymarket_arbitrage or provide when-not-to-use guidance. The context is clear but lacks exclusions.

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 extensive behavioral context: it explains return format (leg prices, top_spreads_pp), safety fields (compatibility_warning, temporal_alignment, skipped_cross_type), and conditions when spreads are invalid (e.g., temporal misalignment, non-equivalent bet shapes). No contradictions with annotations.

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

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

The description is well-structured: first sentence defines purpose, then two modes, then response structure, then safety fields. It is front-loaded with the most important information. However, it is relatively long (approximately 150 words) and could be slightly more concise without losing necessary detail.

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

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

Given the absence of an output schema, the description compensates by detailing the response fields (leg prices, top_spreads_pp, compatibility_warning, temporal_alignment, skipped_cross_type) and explaining their meanings. It covers edge cases like non-equivalent shapes and temporal misalignment. Minor gaps exist: error response format is not described, and some field semantics (e.g., skipped_cross_subtype) could be expanded. Overall, it is thorough for a complex tool.

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

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

Schema coverage is 100% with each parameter described. The description adds value by explaining the two-mode system (topic vs explicit override) and providing a list of valid topic values. It also clarifies that the explicit parameters 'override the topic-mapped side', aiding correct parameter composition. Some nuance is added beyond the schema definitions, justifying a score 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 opens with a clear, specific verb-resource statement: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It immediately distinguishes this tool from siblings like 'polymarket_arbitrage' (which operates within a single venue) and details two distinct modes (topic and explicit). The purpose is unambiguous and sets correct expectations.

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

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

The description explains when to use each mode and sets realistic expectations: 'Real cross-venue spreads are rarer than the macro-shortcut list suggests — most pre-mapped topics return compatibility_warning today; pre-mapped ≠ tradeable.' It implicitly warns against misuse but does not explicitly compare to alternative tools like 'polymarket_arbitrage' for intra-venue analysis. A clear 'when to use this over X' statement would earn 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior: retrieving memories by key or listing all memories, with persistence across sessions. However, it doesn't mention error handling (e.g., what happens if key doesn't exist) or performance characteristics.

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 perfectly concise with two sentences that each serve distinct purposes: the first explains the core functionality, the second provides usage context. There's no wasted language or redundancy.

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

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

For a simple retrieval tool with good schema coverage but no output schema, the description provides adequate context about what the tool does and when to use it. However, without an output schema, it doesn't describe the return format (e.g., structure of retrieved memories), leaving some 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?

The schema has 100% description coverage, so the baseline is 3. The description adds meaningful context by explaining the semantic difference between providing a key (retrieve specific memory) and omitting it (list all keys), which goes beyond the schema's technical specification.

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 with specific verbs ('retrieve', 'list') and resources ('previously stored memory', 'all stored memories'). It distinguishes this tool from siblings like 'remember' (which stores) and 'forget' (which deletes) by focusing on retrieval operations.

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 on when to use this tool: 'to retrieve context you saved earlier in the session or in previous sessions.' It also specifies when to omit the key parameter ('omit key to list all keys'), giving clear operational instructions.

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

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

Annotations already indicate read-only, open-world, idempotent, non-destructive. The description adds behavioral detail on mark_read: 'Set mark_read:true to flag returned events read so the next call only shows newer ones.' It also describes return fields (source, citation_uri, raw payload). No contradictions with annotations.

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

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

The description is well-structured with four sentences: purpose, return details, filtering options, and usage note. It is front-loaded with the main action. No unnecessary words, though the alternative API mention adds a bit of extra length.

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

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

Given the tool has no output schema, the description compensates by detailing what each returned alert carries (source, citation_uri, payload). It also covers polling suitability and provides an alternative access method. For a read-only, 5-parameter tool with no required params, this is highly complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by providing examples for type ('sec_8k') and explaining mark_read behavior and since format ('ISO timestamp'). This enhances understanding beyond the schema descriptions.

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

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

The description clearly states it pulls fired events from the subscription feed. It specifies verb 'Pull' and resource 'fired events from your subscription feed', distinguishing it from sibling tools like list_subscriptions (which lists subscriptions) and search_within. The scope (most recent alerts, filtered by type/since) is well-defined.

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

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

The description explains when to use the tool (pulling alerts, polling) and provides an alternative direct API endpoint at GET registry.pipeworx.io/alerts.json for scripts and dashboards. It does not explicitly list when not to use it, but the context is clear enough for an AI agent.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds significant context: it fans out to multiple sources with fallback behavior (GDELT→GNews), soft-fails for USPTO, and returns structured data with citation URIs. No contradictions with annotations.

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

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

The description is well-structured, starting with purpose, then fan-out details, parameter guidance, return structure, and sibling comparison. Every sentence adds value, though it could be slightly more concise by grouping some details.

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

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

With no output schema, the description adequately explains the return structure (grouped by source, count, URIs) and source behavior. It covers fallback and soft-fail, but lacks error handling details. Overall, it's comprehensive for a complex tool.

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

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

Schema coverage is 100% for all three parameters. The description adds value by providing examples ('AAPL', '0000320193'), clarifying the 'type' parameter is limited to 'company', and suggesting defaults for 'since'. This goes beyond the schema descriptions.

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

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

The description clearly states the tool provides a change feed for a company over time, using phrases like 'What's new with X' and 'change feed for a company in the last N days/weeks/months'. It distinguishes from the sibling tool 'entity_profile' by noting the latter is for static profiles regardless of window.

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

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

The description explicitly advises when to use entity_profile instead, and suggests default values for the 'since' parameter ('30d' or '1m'). However, it does not explicitly state when not to use this tool, such as limitations to company type only.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does an excellent job describing key behavioral traits: it explains the persistence model (authenticated vs. anonymous), storage duration (24 hours for anonymous), and the cross-tool context capability. The only minor gap is lack of information about storage limits or potential errors, but overall it provides substantial behavioral context beyond basic functionality.

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 perfectly concise with just two sentences that each earn their place. The first sentence states the core functionality with examples, and the second provides critical behavioral context about persistence. There's zero wasted language, and the most important information is front-loaded.

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

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

For a 2-parameter tool with no annotations and no output schema, the description provides excellent context about what the tool does, when to use it, and key behavioral characteristics. The only minor gap is the lack of information about return values or potential errors, but given the tool's relative simplicity and the comprehensive behavioral disclosure, this is nearly 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 the schema already fully documents both parameters. The description doesn't add any parameter-specific information beyond what's in the schema. However, it does provide context about what types of values are appropriate to store ('intermediate findings, user preferences, or context'), which gives semantic meaning to the 'value' parameter. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('Store a key-value pair') and resource ('in your session memory'), distinguishing it from sibling tools like 'recall' (likely for retrieval) and 'forget' (likely for deletion). It provides concrete examples of what can be stored ('intermediate findings, user preferences, or context across tool calls'), making the purpose unambiguous and well-differentiated.

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 save intermediate findings, user preferences, or context across tool calls') and provides clear context about persistence differences ('Authenticated users get persistent memory; anonymous sessions last 24 hours'). This gives the agent specific guidance on appropriate use cases and important behavioral constraints.

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

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

No annotations provided, so description carries full burden. Discloses return fields and that it's a single call, but does not explicitly state it is read-only or address potential side effects, rate limits, or error behavior.

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

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

Extremely concise (three sentences) with all key information front-loaded. Every sentence serves a purpose: goal, input formats, output contents, and benefit.

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, inputs, and outputs well given no output schema. Mentions return fields and resource URIs. Could improve by noting error handling or partial match behavior.

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

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

Schema has 100% coverage with descriptions for both parameters. Description adds value by explaining accepted formats for 'value' and clarifying that 'type' is limited to 'company'. Examples further clarify usage.

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

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

Description uses specific verb 'resolve an entity to canonical IDs' and clearly identifies the resource (Pipeworx data sources). It distinguishes itself from sibling tools which are all different (e.g., ask_pipeworx, get_launch).

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

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

Explicitly states it replaces 2-3 lookup calls and gives specific input examples (ticker, CIK, name). Missing 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?

Annotations already indicate readOnly, idempotent, and non-destructive behavior. The description adds valuable context: it internally calls 'ai_visibility_check' for each entity and returns a ranked list with score, confidence, and signal density. This goes beyond the annotations without contradiction.

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

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

The description is efficient: four sentences cover purpose, process, use case, and output. It is front-loaded with the main action and has no superfluous 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 no output schema, the description adequately describes the return format (ranked list with score, confidence, signal density). It explains the internal flow (probes each entity with a sibling tool) and context parameter usage. Minor gaps in limits or error handling are acceptable.

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 parameters. The description does not add significant meaning beyond the schema, except for noting that the first entity is treated as the subject. Baseline of 3 is appropriate.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, using specific verbs and resources. It distinguishes itself from the sibling tool 'ai_visibility_check' which handles single entities, and mentions a concrete use case for competitive audits.

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 clear use case ('competitive AI-marketing audits') and implies when to use this tool over alternatives like the single-entity 'ai_visibility_check'. However, it does not explicitly state when not to use it or list other alternatives beyond the implied sibling.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds details about external service calls, partial failure handling (bundlephobia timeout), and return structure. 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 detailed and front-loaded with purpose. While lengthy, every sentence adds necessary information. Could be slightly more concise, but effective.

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

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

No output schema, so description compensates by listing all return fields (summary block, per-advisory, links, recent versions). Covers ecosystem scope, partial failures, and measurement delays comprehensively.

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 context: defaulting version to latest, accepting scoped packages, and noting bundlephobia measurement delay. This adds value beyond schema.

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

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

The description clearly states it's a composite check for adding an npm package, covering license, advisories, bundle size, etc. It specifies the verb 'scan' and resource 'dependency', distinguishing it from siblings like validate_claim.

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 an agent asks 'is X safe / popular / small' or 'what does adding lodash cost me'. Also mentions ecosystem limitations (NPM v1) and fallback alternatives (deps.dev:version).

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

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

With no annotations provided, the description carries full burden. It discloses the return format (matching launches with specific fields) but lacks critical behavioral details: it doesn't mention pagination, rate limits, authentication needs, error handling, or whether results are sorted. For a search tool, this is a significant gap in transparency.

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

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

The description is efficiently structured in two sentences: the first states the purpose and search scope, the second specifies the return format. Every word earns its place with no redundancy or fluff, making it easy to parse quickly.

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

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

Given the tool's moderate complexity (search with two parameters), no annotations, and no output schema, the description is partially complete. It covers the basic purpose and return fields but omits behavioral aspects like result limits, sorting, or error cases. It's adequate for minimal use but lacks depth for robust agent operation.

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 both parameters fully. The description adds minimal value beyond the schema: it mentions searchable fields (rocket name, mission name, agency) which helps interpret 'query', but doesn't provide additional syntax or format details. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Search launches by keyword' with specific searchable fields (rocket name, mission name, agency, etc.). It distinguishes from sibling tools by focusing on keyword search rather than retrieving specific launches (get_launch) or time-based lists (get_past_launches, get_upcoming_launches). However, it doesn't explicitly name these alternatives for full differentiation.

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

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

The description implies usage context through 'Search launches by keyword' and the examples, suggesting it's for finding launches matching search terms rather than retrieving by ID or time. However, it lacks explicit guidance on when to use this versus siblings like get_past_launches for chronological listings or get_launch for specific IDs, leaving some ambiguity.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds critical details: embedding model (BGE-base-en), window size (500-char overlapping), similarity metric (cosine), 200K char cap with truncation flag, and output format (passages with offsets and scores). This far exceeds what annotations provide.

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

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

Two well-structured sentences: first sentence covers purpose and key benefits (context saving, offsets for verification), second sentence provides technical details (pairing guide, embedding specs, cap). No wasted words; front-loaded with core functionality.

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 semantic search tool with no output schema, the description covers purpose, usage guidelines, technical constraints (cap, model, windowing), output specifics (offsets, scores), and relation to sibling tools. It is fully self-contained and addresses all likely agent questions.

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% (all parameters described), so baseline is 3. The description adds value with example queries for 'query' parameter, explains 'limit' default and range, and mentions truncation cap for 'text'. This provides useful context 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 performs semantic search inside a fetched record, contrasting with sibling tools like 'ask_pipeworx_grounded' and 'search_launches'. It specifies verb 'search' and resource 'inside a record', making 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?

Explicitly states when to use: 'Use when the record is too big to cram into the prompt.' Also mentions pairing with 'ask_pipeworx_grounded' as an alternative workflow. Provides clear context and exclusions.

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=false, which is consistent with creation. The description adds behavioral details: OAuth requirement, rate limits (10 SMS/day), phone verification, and delivery options. However, idempotentHint=true is not addressed—it's unclear if multiple calls with same parameters create duplicates.

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 dense paragraph, but it front-loads the core action and then logically proceeds to requirements, types, and delivery. It is information-dense without fluff, though it could be slightly restructured for readability.

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

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

Given the tool's complexity (multiple subscription types, delivery options, prerequisites), the description covers all essential aspects: account requirement, type-specific parameters, delivery channels with limitations (SMS cap, phone verification), and return value. No output schema is present, but the stated return of subscription ID suffices.

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

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

Schema coverage is 100%, but the description enriches each parameter with concrete examples and usage notes (e.g., sec_8k items codes, polymarket_edge topics). It explains delivery constraints and the patent_grant type's approximate matching behavior, adding 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 creates a subscription to a live-data event stream and returns the new subscription ID. It distinguishes from sibling tools like list_subscriptions and unsubscribe by focusing on creation and providing detailed type 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?

The description gives clear context: requires OAuth account, explains supported types and their parameters, and mentions delivery channels with constraints. However, it does not explicitly state when to use this tool versus alternatives (like recent_alerts for pulling), though the creation purpose 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?

Adds behavioral details beyond annotations: row is deactivated not deleted, historical events remain available via recent_alerts. Idempotent and non-destructive as hinted.

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, front-loaded with primary action.

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

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

Covers purpose, ownership, side effects, and result silently. Adequate for a simple mutation with one parameter and no output schema.

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

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

Schema already describes id as 'Subscription id (uuid) returned by subscribe.' Description adds 'by id' and ownership context, but mostly redundant with 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 'Cancel a subscription by id' with specific verb and resource. Distinct from siblings like 'subscribe' and 'list_subscriptions'.

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

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

Specifies ownership enforcement ('you can only cancel your own subscriptions'), guiding when to use. Mentions deactivation vs deletion for context, but lacks explicit alternatives like 'list_subscriptions' to check ownership.

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

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

The description adds significant value beyond annotations. Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description details the return format (verdict, structured form, actual value with citation, percent delta) and explains that it replaces multiple sequential calls, providing rich behavioral context.

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

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

The description is front-loaded with trigger phrases and is well-structured, but it is somewhat verbose. However, every sentence adds value, and the length is justified given the complexity of the tool. Slightly more conciseness could improve it.

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

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

Despite the lack of an output schema, the description fully explains what the tool returns (verdict, structured form, actual value with citation, percent delta). It also specifies the domain and the efficiency gain (replacing 4-6 calls), making it complete for an agent to understand and use.

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

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

The single parameter 'claim' has 100% schema coverage with a clear description. The description reiterates the parameter with natural-language examples, reinforcing the meaning beyond the schema.

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

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

The description clearly defines the tool as natural-language claim verification against authoritative sources, specifically for company-financial claims. It provides trigger phrases and explicitly distinguishes from siblings by stating it replaces 4-6 sequential calls, making the purpose unambiguous.

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

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

The description explicitly states when to use it: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also specifies the supported domain (company-financial claims). However, it does not explicitly mention when not to use it or provide direct alternatives, though sibling tools are listed.

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