Saber

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

The description adds minimal behavioral context by indicating that a custom question is used, which suggests an AI/research operation. However, it does not disclose side effects, caching, credit consumption, asynchronous processing, or output characteristics. Annotations (readOnlyHint:false, openWorldHint:true) provide some safety signals, but the description itself offers very little beyond the phrase 'custom question'.

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 sentence with no wasted words, and it front-loads the core differentiator ('custom question'). It is concise and easy to parse, though it sacrifices depth for brevity.

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

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

Given the complexity of the tool (huge schema, no output schema, many options for answerType, templates, webhooks, verification), the description is insufficient. It fails to explain what an enrichment returns, whether results are cached, or how to choose this over standard enrichment tools. The extensive schema documentation prevents a score of 1, but the top-level operational context is largely missing.

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

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

The input schema provides rich descriptions for all parameters, including examples, defaults, and detailed explanations for webhook, forceRefresh, outputSchema, and verificationMode. The tool description itself adds no parameter-level meaning beyond the general 'custom question' context, so the schema carries the full burden and the baseline 3 is appropriate.

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

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

The description uses a specific verb ('Enrich') and identifies the resource ('a company') plus the distinguishing mode ('custom question'), which differentiates it from sibling tools like companies-enrich_firmographics or companies-enrich_funding. However, it does not state what enrichment produces or how it relates to signals/templates, so it's not a 5.

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 phrase 'custom question' weakly implies this tool is intended for ad-hoc research questions rather than predefined enrichment types, but it gives no explicit when-to-use or alternative guidance. There is no mention of batch variants, template usage, or when to prefer standard enrichment tools, so it only reaches an implied level.

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 disclose readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the description's job is lighter. It adds context about batch size ('many companies') and custom questions, but doesn't mention asynchronous behavior, webhook usage, or that 'question' is optional. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence with no filler. It conveys the core purpose immediately and is easy to parse.

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

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

Given the complex nested request body (many optional fields), no output schema, and vague annotations, the description is insufficient. It doesn't hint at batch limits (max 100 targets), webhook callbacks, or async behavior, and misleadingly implies 'one custom question' is required when only 'targets' is required. More context is needed for an agent to invoke correctly.

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

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

The description maps 'many companies' to the 'targets' array and 'custom question' to the 'question' field, giving some semantic anchor. However, the schema already describes 'targets', and many other nested fields (answerType, connectors, webhookUrl, forceRefresh, etc.) are left unexplained. With high schema coverage, a 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 uses a specific verb 'Enrich' plus a clear resource scope: 'many companies' with 'one custom question'. This distinguishes it from sibling tools like companies-enrich_custom (single company) and other enrich types such as firmographics or funding.

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 phrase 'many companies' clearly indicates this is for batch enrichment, implying use when multiple companies need the same custom question. It does not explicitly name alternatives or exclusions, but the batch context is evident from the sibling tool 'companies-enrich_custom'.

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 no behavioral context beyond the annotations. Despite annotations indicating openWorldHint and non-read-only, the description does not explain side effects, caching behavior (forceRefresh), or webhook delivery, all of which are hinted at in the schema but absent from the description.

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 clear sentence with a verb-object structure, no fluff, and front-loaded action. It is appropriately concise, though minimal.

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 and the need for agents to understand what 'firmographics' includes, the description is too sparse. It does not explain the data domain, return value, or trade-offs with other enrichment tools, making it incomplete for correct tool selection.

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

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

Schema covers 100% of parameters with detailed descriptions for domain, webhookUrl, and forceRefresh. The description itself adds no parameter-specific meaning, so the baseline of 3 applies due to 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 uses the verb 'enrich' with the resource 'company' and object 'firmographics,' clearly identifying the action. However, it does not distinguish this from sibling tools like companies-enrich_funding or companies-enrich_tech_stack, which follow the same enrich pattern.

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 instead of alternatives. The description is a single sentence with no mention of selection criteria, prerequisites, or exclusions, leaving the agent to infer from the name alone.

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, idempotentHint=false, and destructiveHint=false, but the description adds no behavioral context. It doesn't explain potential side effects (e.g., credit usage, async processing, webhook delivery) that go beyond the structured annotations.

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

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

The description is a single, focused sentence with no filler. It front-loads the action and results, making for an appropriately concise and easily scanned tool definition.

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

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

The description is minimal and lacks important context. It doesn't explain the nature of funding status data, whether the operation is synchronous or async, what the response contains, or that webhookUrl and forceRefresh are available. Given the tool has a nested request body and no output schema, more descriptive context is needed.

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

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

Schema description coverage is 100%, so all parameters (domain, webhookUrl, forceRefresh) are already described in the schema. The description adds no additional parameter meaning beyond the general 'company' context.

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

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

The description states a clear verb and resource: 'Enrich a company with funding status.' It distinguishes from sibling tools like enrich_firmographics or enrich_mna by specifically mentioning funding status. However, it is somewhat terse and could elaborate on what 'funding status' entails.

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 explicit guidance on when to use this tool versus alternatives. It doesn't mention use cases, prerequisites, or differences from other enrichment tools in the sibling list.

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

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

Annotations provide openWorldHint=true and readOnlyHint=false, but the description adds no additional behavioral context such as asynchronous execution, side effects, credit consumption, or caching behavior. The description does not contradict annotations.

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

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

The description is a single, concise sentence that is front-loaded with the core purpose. It is efficient but somewhat under-specified for a tool with this complexity.

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

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

Despite having a nested schema and no output schema, the description does not explain return values, asynchronous behavior, or what M&A activity data actually includes. The description is too sparse to be considered complete for this tool.

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

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

The input schema fully documents all parameters (domain, webhookUrl, forceRefresh) with descriptions, so the baseline is 3. The tool description adds no meaning beyond the schema; it only provides the M&A context.

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

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

The description clearly identifies the verb 'enrich', the resource 'company', and the scope 'M&A activity'. It effectively distinguishes this tool from sibling enrich tools by the activity type, though it does not explicitly name alternatives.

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 offers no guidance on when to use this tool versus alternatives such as companies-enrich_funding or signals-mna. There is no mention of exclusions, prerequisites, or preferred use cases.

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

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

The description does not disclose behavioral traits such as async execution, side effects, credit costs, or return format. While annotations indicate readOnlyHint=false and openWorldHint=true, the description adds no further context about what 'enrich' entails or potential side effects beyond the annotations themselves.

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

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

The description is a single compact sentence with no filler, making it concise and front-loaded. It is slightly less detailed than ideal, but it earns its place as a brief statement of the tool's core function.

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 should explain what 'enrichment' produces, when to use webhookUrl, and how forceRefresh behaves. It does none of these, leaving important contextual gaps for an enrichment tool that supports async webhooks and caching 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?

The input schema fully covers all parameters with descriptions (domain, webhookUrl, forceRefresh), so the tool description adds no additional parameter meaning. Since schema description coverage is 100%, a baseline score of 3 is appropriate.

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

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

The description 'Enrich a company with open jobs' clearly states the verb (enrich), resource (company), and data (open jobs), making its purpose explicit. However, it does not distinguish this tool from siblings like companies-enrich_firmographics or signals-open_jobs, which also relate to company enrichment.

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, nor does it mention any prerequisites, exclusions, or preferred use cases. It is a single statement without contextual usage information.

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 no behavioral context beyond the annotations. It does not disclose caching behavior, webhook delivery, auto-resolution of technology names, or the distinction between sync and async endpoints. The parameter descriptions in the schema carry that burden, but the tool description itself is silent.

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 sentence with no filler, achieving maximum conciseness. It is front-loaded with the core action and resource, and every word is meaningful.

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 five parameters, a nested request body, and no output schema, the one-sentence description is minimal but not misleading. The schema provides detailed parameter info, and annotations cover read/write hints, but the description omits high-level context such as sync/async behavior or mutual exclusivity of category and technology.

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 fully documents parameters like domain, category, technology, webhookUrl, and forceRefresh. The description adds no parameter-level meaning, but the baseline of 3 is appropriate given that the schema handles semantics.

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

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

The description uses a clear verb ('Enrich') and resource ('a company') with a specific scope ('its tech stack'), which distinguishes it from sibling enrichment tools like firmsgraphics or funding. However, it lacks detail about the optional parameters (category, technology) that define the type of tech stack enrichment.

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. While the sibling list includes other enrichment tools (e.g., companies-enrich_firmographics), the description does not mention any differentiators, prerequisites, or scenarios where this tool is preferred.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, but the description adds no behavioral context such as whether the operation is asynchronous, consumes credits, or has rate limits. It simply repeats the action without disclosing side effects beyond what annotations already imply.

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

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

The description is a single, concise sentence that front-loads the core action and resource. It is appropriately brief for a simple tool with one parameter, though it sacrifices detail for brevity.

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

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

Given the tool's simplicity, the description is only minimally complete. It omits critical context about the nature of the summary output, whether it is synchronous, or how it relates to other enrichment and summary tools. This is a significant gap for an agent that needs to understand the tool's purpose and side effects.

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 provides 100% coverage with a clear description for the 'domain' parameter, so the baseline is 3. The description itself adds no parameter-related information, but it does not need to because the schema is sufficient.

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

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

The description states a specific action ('generate') on a resource ('company summary'), which clarifies the basic purpose. However, it does not define what a company summary contains, and it does not distinguish this tool from siblings like companies-list_summaries or signal_summaries-generate, leaving ambiguity about the output type.

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 offers no guidance on when to use this tool versus alternatives. It lacks any mention of prerequisites, scenarios, exclusions, or differentiation from adjacent tools, so an agent receives no help with selection.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is known. However, the description adds no additional behavioral context, such as pagination behavior, required 'domain' parameter, or what a summary contains.

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 only four words, making it highly concise. However, it is under-specified to the point of being minimal; it does not provide any structural elements like usage scenarios or parameter notes. It earns a middle score because it is not verbose but lacks substance.

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 and minimal description, the tool is under-documented. It does not mention required parameters, pagination, or return value structure, leaving important gaps for a tool with three parameters and no schema descriptions.

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 0%, and the description does not explain any parameters. While 'domain', 'limit', and 'offset' are somewhat self-explanatory, the description adds zero value for parameter semantics, leaving the agent without clarification on required 'domain' or pagination constraints.

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 'List company summaries' uses a specific verb ('List') and resource ('company summaries'), making the tool's purpose clear at a high level. It does not explicitly distinguish from sibling tools like signal_summaries-list, but the company domain is evident from the tool name.

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 such as companies-generate_summary or signal_summaries-list. There is no mention of prerequisites, filtering, or use cases.

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

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

With annotations present (readOnlyHint=false, openWorldHint=true), the bar is lower. The description adds useful context about credit cost estimation, but it does not disclose whether the preview itself consumes credits, whether it is safe, or what response format to expect. No contradiction with annotations, but behavioral detail is minimal.

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 sentence that is front-loaded with the key action ('Estimate') and packs both output variables (match count and credit cost) with no wasted words.

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

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

The tool has a complex nested filter schema, but the schema itself covers parameter semantics thoroughly. No output schema exists, yet the description directly states what the output will tell the agent (number of matches and credit cost). It is slightly incomplete because it does not mention when such a preview is useful or how it fits into the broader list operation workflow, but the core purpose is adequately explained.

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

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

Schema description coverage is 100% — the filter object and all nested properties have descriptions like 'Filter by company names' and 'Filter by company size ranges'. The tool description adds no parameter-level detail beyond the word 'filter', so it does not improve on the schema. 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 uses a specific verb ('Estimate') and clearly states the resource (companies matching a list filter) and the outcome (count and credit cost). This distinguishes it from siblings like company_lists-get_companies (which would likely return actual companies) and credits-get_balance (which displays current balance).

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 a pre-flight use case by saying what the list operation 'would cost', but it does not explicitly state when to use this tool over alternatives, nor does it mention any exclusions or prerequisites. It provides clear context but lacks direct usage guidance.

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

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

Annotations already indicate readOnlyHint: false and destructiveHint: false, so the agent knows this is a write operation. The description adds minimal behavioral detail beyond the word 'Save' and doesn't disclose any side effects, idempotency, or edge cases. However, with annotations covering the safety profile, the description is acceptable but not rich.

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?

A single sentence that is concise and front-loaded with the core action ('Save a company filter as a reusable list') followed by relevant usage contexts. No wasted words.

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

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

For a create tool with a rich underlying schema, the description gives enough high-level context (what the list is used for) and relies on the schema for parameter detail. It doesn't explain return values, but no output schema exists, so that's not required. It could mention that the filter supports both inclusion and exclusion criteria, but the schema already documents that.

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

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

The input schema has 100% coverage with detailed descriptions for all parameters (e.g., name, filter with nested objects like exclude, location, founded). The description adds no parameter-level detail, but since schema coverage is high, the 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 uses a specific verb ('Save') and clear resource ('a company filter as a reusable list'), clearly distinguishing this creation tool from sibling tools like company_lists-list or company_lists-update. It also mentions the purpose of the list (for review, signals, scoring, export, CRM workflows), adding practical context.

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

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

The description implies the tool is used when a company filter needs to be persisted for future workflows, which provides clear context. It doesn't explicitly mention alternatives or when not to use it, but the naming and wording make it obvious this is the create operation among the company_lists siblings.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is known. The description adds value by explaining a non-obvious side effect: the removed list also removes its 'reusable segment boundary.' This is meaningful behavioral context beyond the annotations, though it does not detail irreversibility or cascading effects.

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, concise sentence with no filler. Both clauses carry important information: the core action and the segment boundary side effect. It is appropriately front-loaded and every word 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?

For a simple one-parameter delete operation with strong annotations (destructive, idempotent) and no output schema, the description provides the essential behavioral nuance (segment boundary removal) and relies on schema for parameter semantics. It is complete enough, though it could mention permanence or behavior on non-existent lists, but idempotentHint mitigates that concern.

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 fully describes the single parameter listId as 'The unique identifier of the company list to delete' (100% coverage). The description does not add any additional parameter meaning, so it relies on the schema. The baseline of 3 applies here.

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 ('saved company list'), and adds a specific consequence ('remove its reusable segment boundary'). This distinguishes it from other list operations like company_lists-get or company_lists-update, and clearly identifies the domain (company lists vs. contact lists).

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: it is the tool for deleting saved company lists. However, it does not explicitly state when to use this over alternatives (e.g., contact_lists-delete) or mention any prerequisites or exclusions. The context of the tool name and sibling set makes the usage clear, but explicit guidance is lacking.

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

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

Annotations already provide readOnlyHint=false, destructiveHint=false, and openWorldHint=true. The description adds no context about side effects, asynchronous behavior, file handling, or authentication requirements. For an export operation that may create a file or return a download link, the lack of behavioral detail leaves significant ambiguity 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 a single, front-loaded sentence that directly states the action, resource, and optional parameters. It contains no filler or redundant information, earning full marks for conciseness.

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

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

There is no output schema, so the description should explain what the agent should expect in return. 'Export to CSV' implies a CSV file, but it does not clarify whether the tool returns the file content, a download URL, or an async job ID. Given the moderate complexity (nested request body) and annotations indicating open-world behavior, the description is adequate but not fully 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 input schema already documents listId and the request body fields with clear descriptions. The tool description merely summarizes 'firmographic and signal columns' without adding any details beyond what the schema provides. Baseline 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 states a specific verb ('Export') and resource ('saved company list') with a clear output format ('CSV'), distinguishing it from siblings like company_lists-get or count_preview. It also mentions optional column selection, making its functionality precise.

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 'Export a saved company list to CSV' clearly implies the use case of obtaining a CSV export, but it does not explicitly compare with alternatives such as company_lists-get_companies (which likely returns structured JSON) or state when not to use the tool. No exclusion criteria or alternative suggestions are provided, leaving usage to be inferred.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds detail about the metadata contents (filter and company count) but does not disclose other behavioral aspects like error handling or permissions. This is acceptable given the annotation coverage.

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

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

The description is a single concise sentence, front-loads the verb, and contains no extraneous information.

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

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

The tool is simple with one parameter and no output schema. The description explains that it returns metadata including filter and company count, which covers the main return value. However, it doesn't enumerate all possible metadata fields or specify error scenarios, but this is likely sufficient for a basic metadata retrieval.

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

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

The input schema provides a complete description for the single parameter listId (100% coverage), so the description does not need to add parameter syntax. The description adds no parameter-specific meaning beyond the schema.

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

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

The description uses the specific verb 'retrieve' and identifies the resource as 'company list metadata', specifying key contents (filter and company count), which clearly distinguishes it from siblings like company_lists-get_companies or company_lists-list.

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

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

The description provides clear context that this tool is for metadata retrieval, but it does not explicitly mention alternatives or conditions when not to use it. The sibling context implies distinction, but the description itself lacks explicit usage guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe read-only nature is covered. The description adds the pagination behavior and the dependency on a saved list filter, but does not disclose details like result ordering, empty results, or error behavior. This is minimal additional value over annotations.

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

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

The description is a single sentence that directly states the tool's function without filler or repetition. It is front-loaded and easy to scan.

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 paginated read tool with well-described parameters and safe annotations, the description is nearly complete. It could mention what happens when no companies match or how results are ordered, but these are not essential for correct invocation. The lack of an output schema is partially offset by the clear statement that it returns companies.

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 provides 100% coverage with clear descriptions for limit, listId, and offset, so the description does not need to add parameter details. The term 'page through' reinforces the role of limit/offset, but adds no new semantics beyond the schema.

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

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

The description uses a specific verb ('Page through') and identifies the exact resource ('companies that match a saved company list filter'), clearly distinguishing it from related tools like company_lists-get (list metadata) and company_lists-list.

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 clearly implies the tool is for paginating through companies in a saved list, but it does not explicitly state when to use it versus alternatives like company_lists-search, company_lists-get, or contact_lists-get_contacts. No exclusions or conditions are mentioned.

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

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

Annotations already signal a non-read-only, non-idempotent mutation (readOnlyHint=false, idempotentHint=false). The description adds minimal behavioral context beyond that, such as implying the creation of a saved list, but does not disclose potential side effects or rate limits. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence that states the action and source/destination without waste. It is concise and readable.

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 nested objects and no output schema, the description is sparse but the schema fills most gaps. Still, it doesn't clarify the relationship between the filter and HubSpot list/view/segment, and it doesn't confirm whether a new list is created or an existing one is appended. Enough for basic use but with clear gaps.

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

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

Schema coverage is 100% and the schema describes parameters in detail. However, the description's mention of 'HubSpot list, view, or segment' conflicts with the actual filter-based source schema, potentially misleading the agent into expecting a list ID rather than a property filter. This actively detracts from parameter understanding.

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 a specific action ('Import companies from a HubSpot list, view, or segment into a saved Saber company list') that distinguishes the tool from siblings like create, delete, or export. However, it refers to 'list, view, or segment' while the schema describes a property-based filter, making the source more ambiguous than it should be.

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 importing from HubSpot, but it does not explicitly state when to use this tool over alternatives or provide any exclusions. No alternatives are mentioned, and the context is only implicit through the tool name and description.

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 pagination behavior, which is not covered by the annotations. Annotations already provide readOnlyHint, idempotentHint, and destructiveHint, so the bar for additional disclosure is lower. The description does not contradict annotations and adds useful 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 a single concise sentence with no redundancy. It delivers the core purpose and key behavioral detail (pagination) efficiently.

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

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

For a simple list-with-pagination tool, the description is complete. Annotations cover safety profile, schema covers parameter details, and the purpose is clear. With no output schema, the implied return of company lists is sufficient.

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

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

The input schema fully describes both limit and offset with ranges and defaults, achieving 100% schema description coverage. The description's mention of pagination aligns with the schema but adds no new parameter semantics beyond what the schema already provides.

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

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

The description clearly states the action (List) and resource (saved company lists), and mentions pagination. It effectively distinguishes from sibling tools like get, search, and count_preview by implying a full enumeration.

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 a clear purpose but does not explicitly state when to use it versus alternatives such as company_lists-search or company_lists-get. Usage context is implied by the name and action, but there are no explicit when/when-not or alternative references.

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 says 'Preview,' which implies a read-only operation, but the annotations set readOnlyHint: false, indicating the tool may not be read-only. This is a direct contradiction, and no other behavioral traits (e.g., authentication needs, rate limits, side effects) are disclosed. The annotation contradiction per the rubric forces a score of 1.

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, front-loaded sentence: 'Preview up to 50 companies that match a filter before creating a reusable company list.' It states the action first, includes the key limit, and contains no extraneous words. Every word 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?

The description covers the purpose and output limit but does not describe the structure of the returned company data, and there is no output schema to compensate. The rich input schema and clear preview context make it usable, but the lack of return-value details leaves a gap for an agent deciding how to use the results.

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

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

The schema provides detailed descriptions for all filter properties (names, sizes, types, domains, exclude, founded, handles, location, websites, industries, questionIds, technologies), achieving 100% schema description coverage. The tool description adds no additional parameter-specific meaning, 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's function: 'Preview up to 50 companies that match a filter before creating a reusable company list.' This includes a specific verb (preview), a resource (companies), an output limit (up to 50), and the intended use case (before creating a list). It distinguishes the tool from siblings like company_lists-create (which creates) and company_lists-count_preview (which likely only counts).

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 when to use the tool: 'before creating a reusable company list.' However, it does not explicitly name alternatives or exclusions, such as 'use company_lists-count_preview for just a count' or 'use company_lists-create to immediately create.' This is clear context but lacks explicit when-not-to-use guidance.

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

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

The description discloses a non-obvious side effect: 'refresh cached matching companies.' This goes beyond the annotations (readOnlyHint=false, idempotentHint=true, destructiveHint=false) by explaining that the operation triggers a cache refresh. It does not contradict any annotation and adds useful 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 entire description is one succinct sentence that front-loads the main action ('Update a company list') and includes an important side effect. There is 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?

With no output schema, the description covers the tool's purpose and a key side effect, which is sufficient for a basic update operation. However, it omits the fact that both name and filter are always required (contradicting the 'or' phrasing) and provides no error-handling or prerequisite context. The rich schema compensates for input details but not for these high-level behavioral nuances.

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 name and filter properties in detail. The description adds only that the update affects the name or filter and that matching companies are refreshed, which is largely a behavioral note. It does not clarify parameter formats, defaults, or the requirement to provide both fields.

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

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

The description clearly identifies the action ('Update') and the resource ('a company list'), and it distinguishes the tool from siblings like company_lists-create or company_lists-delete. However, it says 'name or filter' while the schema requires both fields in the request body, which is slightly misleading about the update semantics.

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 the tool is used for updating a company list but gives no explicit guidance on when to choose this tool over alternatives such as contact_lists-update or when not to use it. It lacks exclusions or alternative references, providing minimal contextual guidance.

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

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

The description adds key behavioral context beyond annotations: it explicitly states the API returns immediately and results are obtained by polling the signal ID or via webhook. This is valuable operational information not covered by the annotations, which only indicate non-read-only, non-destructive, open-world 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?

A single sentence with no waste, front-loaded with the primary action and object. It efficiently conveys both the purpose and the key async behavior.

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

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

Given the tool's complexity and rich input schema, the description provides the essential async workflow but omits guidance on alternative tools and edge cases like cache behavior or webhook limitations. It is adequate but not comprehensive.

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

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

Schema description coverage is 100% and each property has detailed descriptions with examples and constraints. The tool description itself adds no parameter-level information, so the schema carries the full semantic burden, warranting the baseline score.

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 company research signal, using a specific verb and resource. It differentiates from retrieval tools (get/list) but does not explicitly distinguish from the batch creation sibling, making the distinction implicit.

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 the asynchronous execution model (return immediately, poll or webhook) but provides no guidance on when to use this tool versus alternatives like company_signals-create_batch or the get/list tools. No exclusions or preferred use contexts are mentioned.

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 no behavioral information beyond what annotations already provide. Annotations indicate readOnlyHint=false, destructiveHint=false, and openWorldHint=true, and the description simply says 'Create many company signals' without disclosing side effects, rate limits, async behavior, or other consequences. The schema contains rich details, but the description itself contributes no extra 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 two sentences, front-loaded with the primary action, and contains no unnecessary words. It efficiently conveys the tool's purpose and a single high-value usage tip about templates.

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 (nested objects, async mode, webhooks) and the lack of an output schema, the description is quite sparse. However, the input schema is highly detailed and covers most behavioral and parameter information, including async return shapes. The description could be more helpful by hinting at response formats or typical use cases, but it is minimally adequate when combined with the 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 description coverage is 100%, so the baseline is 3. The description's mention of 'domains, questions, or templates' roughly maps to the domains and signals parameters, but this adds little meaning beyond the already comprehensive schema descriptions. It does not provide additional syntax, constraints, or examples beyond what the schema documents.

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

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

The description clearly states the tool creates many company signals, using the specific verb 'create' and resource 'company signals'. It distinguishes itself from the sibling company_signals-create by emphasizing 'many' and 'batch', and mentions domains, questions, and templates as scope.

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

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

The description provides clear context that this tool is for creating multiple signals at once, distinguishing it from single-create alternatives. It also gives specific guidance to 'use templates for larger standardized batches', which is a useful usage hint. However, it does not explicitly mention alternatives like company_signals-create or list when-not conditions.

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

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

Annotations already declare readOnly and idempotent hints. The description adds behavioral context by specifying the return includes status and AI-generated answer, and that it applies when the signal has completed, hinting at a state-dependent response.

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, information-dense sentence that is front-loaded with the verb 'Retrieve' and includes all necessary context without any filler.

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

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

For a one-parameter, read-only getter, the description adequately covers purpose, return content (status and answer), and the completion condition. It does not detail status values or error behavior, but these are not critical for such a simple tool with strong annotations.

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 provides 100% coverage for the single parameter signalId with a clear UUID description. The tool description does not add extra parameter semantics, but none are needed given the 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 retrieves the current status and AI-generated answer for a company signal, with a specific condition (when it has completed). This distinguishes it from sibling tools like company_signals-list or company_signals-create.

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 phrase 'when it has completed' implies the tool is intended for retrieving results after signal completion, contrasting with list/create tools. It does not explicitly name alternatives or exclusions, but context provides clear usage guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering safety. The description adds no further behavioral details beyond saying 'List', so it provides minimal value beyond the annotations.

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

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

A single concise sentence that states the action and the main filter categories. No unnecessary words or repetition.

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

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

Given the simple list operation, the description is sufficient for a basic understanding. It does not explain pagination or return format, but the schema includes limit/offset and the operation is simple enough that the agent can infer the behavior. The lack of an output schema is not a major gap for a straightforward list tool.

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

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

Schema description coverage is 100%, with all 8 parameters documented in the schema. The description merely restates the categories of filters (domain, company ID, etc.) without adding any new meaning, so it 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 'List company signal runs' with a specific verb and resource, and mentions optional filters. This distinguishes it from sibling tools like company_signals-get (which likely retrieves a single signal) and company_lists-list (which lists different entities).

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

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

The description makes it clear that this tool is for listing signal runs, which is a distinct operation from getting a single run or creating runs. However, it does not explicitly mention when not to use it or name alternatives, so it falls short of full usage guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is clear. The description adds scoping to a specific subscription and mentions filters/pagination, but doesn't disclose additional traits like response structure or rate limits, so it adds only modest 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?

The description is a single concise sentence front-loaded with the verb and resource, containing no redundant or extraneous information. It efficiently communicates the tool's core action and scope.

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 a rich input schema with full parameter descriptions and strong annotations, the description sufficiently covers the tool's purpose and scope. However, there is no output schema and the description doesn't describe return value structure or pagination response details, leaving some ambiguity about what the agent will receive.

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

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

Schema description coverage is 100%, with all 8 parameters documented in the input schema, including defaults, formats, and filter semantics. The description only generically mentions 'filters and pagination' without adding any parameter-specific meaning beyond what the schema already provides.

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

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

The description uses the specific verb 'List' and identifies the resource as 'company signal executions produced by a specific signal subscription', which clearly distinguishes it from sibling tools like company_signals-list that may list signals more broadly. It also mentions filters and pagination, reinforcing the tool's specific role.

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 by requiring a 'specific signal subscription' through the required subscriptionId, but it does not explicitly state when to use this tool versus alternatives, nor does it mention exclusions or contrast with similar list tools in the sibling set.

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, covering the safety profile. The description adds the detail that it returns 'connection status', which is useful context, but it does not elaborate on what counts as a connector or how status is represented. This is adequate but not rich.

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, concise sentence that front-loads the action and resource. Every word is informative, with no filler or repetition of the tool name.

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 list operation with no parameters and no output schema, the description provides the essential information: it lists connectors and their status. However, it could be more complete by mentioning whether the list includes all connectors or if any pagination/limitations apply, but given the tool's simplicity this is a minor gap.

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 tool has zero parameters, so the schema is fully covered (100% coverage) by default. The description does not need to explain parameters, and the baseline for zero parameters is 4. There is nothing to add.

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

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

The description clearly states the verb 'List' and the resource 'connectors', and specifies that it returns 'connection status'. This is specific and distinguishes it from sibling tools, which are all focused on other entity types like company_lists, contact_lists, or signals.

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 checking connectors and their statuses, but there is no explicit guidance on when to use this tool versus alternatives. There are no similarly named sibling tools, so alternatives are not relevant, but the description could have noted a use case like 'check before sending data' to be clearer.

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, so the description's statement that it 'stores' a snapshot is consistent and adds a valuable nuance (point-in-time). However, it does not disclose potential side effects such as credit usage, latency, or whether the search is executed immediately. It adds some context beyond annotations but not rich behavioral detail.

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

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

The description is a single sentence that is front-loaded with the core action and contains no filler. Every phrase adds value, making it 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?

The description explains the creation process and return type ('metadata'), but with no output schema, it leaves some gaps such as what the metadata includes or whether the operation is synchronous. The schema covers the input complexly, but the description could be more complete regarding response shape and potential limitations.

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

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

The schema covers 100% of parameters with descriptions, so the baseline is 3. The description does not add additional parameter-specific meaning beyond what the schema already provides, and the schema descriptions are adequate for the parameters.

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

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

The description uses a specific verb ('Run'), identifies the resource ('LinkedIn Sales Navigator search'), and explains the key actions: storing a point-in-time contact snapshot and returning contact list metadata. This clearly distinguishes it from sibling tools like contact_lists-update or contact_lists-get.

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 does not provide any explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. While the name implies creation, the description simply states what it does and offers no context like 'use for creating new lists; use contact_lists-update for modifications.'

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 destructiveHint=true and readOnlyHint=false, but the description adds useful behavioral context: the deletion is permanent and also removes stored contact snapshots. This goes beyond the annotations by specifying exactly what gets destroyed. No contradiction with annotations.

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

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

A single, front-loaded sentence that conveys the action, the resource, and the consequence. No unnecessary words or repetition.

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 delete tool with one parameter, the description is sufficiently complete. It clarifies the destructive scope (permanent deletion of list and snapshots) and is consistent with annotations. No output schema is provided, so return values are not required. Minor addition could include a warning about irreversibility, but 'permanently' already conveys that.

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 provides 100% coverage for the only parameter, listId, with its description 'The unique identifier of the contact list.' The description adds no additional parameter-level meaning, so the baseline 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 a specific verb+resource: 'Permanently delete a contact list' and adds the scope that it also deletes 'stored contact snapshots.' This distinguishes it from sibling tools like contact_lists-create/get/update/list and company_lists-delete by specifying the exact resource and effect.

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

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

Usage is implied by the verb 'delete' and the permanent nature, but there is no explicit guidance on when to choose this vs alternatives (e.g., contact_lists-update, contact_lists-list) or any mention of prerequisites or exclusions. It gives clear context but no differentiation.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds that it retrieves metadata and a count, which is useful but not extensive. 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?

A single, concise sentence that is front-loaded with the action and resource. No wasted words.

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

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

For a simple one-parameter read-only tool, the description is adequate. It mentions what is returned (metadata and count) without an output schema. Could be slightly more detailed about return format, but unnecessary for this complexity.

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

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

Schema description coverage is 100% for listId, fully explaining its purpose. The description doesn't add additional semantics beyond what's in the schema, so baseline 3 is appropriate.

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

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

The description clearly states the verb 'Retrieve' and the resource 'contact list metadata', while adding the specific detail of 'stored contact count'. This distinguishes it from sibling tools like contact_lists-get_contacts and contact_lists-list.

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: use when you need metadata and a count for a specific contact list. It doesn't explicitly exclude alternatives or mention siblings, but the context is clear. A brief note on when to use this instead of contact_lists-get_contacts would elevate it.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, etc.), the description discloses a significant behavioral trait: it does not make a new Sales Navigator request, implying cached data and potential staleness. This is useful context not covered by annotations.

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

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

The description is a single sentence, front-loaded with the action ('Page through contacts'), and contains no redundant information. Every word contributes value.

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

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

For a simple pagination tool with strong annotations and full schema coverage, the description is sufficient. It explains the core use case and the key limitation (no new request). It does not detail return format, but the absence of an output schema makes that less critical given the simplicity.

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

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

The input schema already fully documents all three parameters (limit, listId, offset) with descriptions and ranges. The description adds no additional parameter-specific meaning, so the 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's purpose: 'Page through contacts stored in a saved list' with a specific verb and resource. It also adds scope ('without making a new Sales Navigator request') that distinguishes it from sibling tools like contact_lists-get or contacts-search.

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

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

The description provides clear context for when to use the tool—when you want to iterate over contacts that already exist in a saved list, avoiding a new API request. It implies a prerequisite (the list is already saved) and suggests it for pagination scenarios, but does not explicitly name alternatives or state when not to use it.

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 destructiveHint=false, covering the safety profile. The description adds 'with pagination', which is also evident from the limit/offset schema parameters, so it adds minimal behavioral context beyond the annotations.

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

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

The description is a single concise sentence with no filler. It front-loads the action and resource, and mentions pagination without redundant 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?

For a simple list tool with two well-documented parameters and rich annotations, the description covers the essential purpose. It does not describe the return format, but no output schema exists and the action 'list' implies the return of lists. Slightly more detail on sorting or response shape would improve completeness, but it is adequate.

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

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

Schema description coverage is 100% for both limit and offset, so the schema already fully documents the parameters. The description does not add any additional meaning to the parameters 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 verb 'List' and the resource 'saved contact lists', and adds the pagination aspect. This distinguishes it from sibling tools like contact_lists-get (single list) and contact_lists-create/delete/update.

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 listing contact lists with pagination, but provides no explicit alternatives or when-not-to-use conditions. It does not mention using contact_lists-get for a single list or how pagination should be handled in practice.

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

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

Annotations already convey readOnlyHint=false, destructiveHint=false, and idempotentHint=true. The description adds valuable behavioral context by stating that the stored contact snapshot is unaffected, clarifying exactly what side effects the rename operation does not have. It does not discuss permissions or error conditions, but the added constraint is meaningful.

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, front-loaded sentence—'Rename a saved contact list without changing its stored contact snapshot.' Every clause adds meaning, with no filler or repetition, making it highly efficient 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?

For a simple rename mutation with full schema coverage, helpful annotations, and a precise one-sentence behavior description, the tool is largely well-specified. The lack of an output schema and no mention of return value or error behavior is a minor gap, but the operational contract is otherwise clear.

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

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

The input schema provides complete descriptions for both parameters: listId as 'The unique identifier of the contact list' and name as 'New display name for the contact list' with an example and maxLength. The description adds no additional parameter-level detail beyond the schema, so the 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 uses a specific verb ('Rename') and resource ('saved contact list'), and further scopes the action with 'without changing its stored contact snapshot.' This clearly distinguishes it from sibling tools like contact_lists-create, contact_lists-delete, or contact_lists-get_contacts, and leaves no ambiguity about what the tool does.

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

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

The description clearly states the tool is for renaming a list and explicitly notes the snapshot is unchanged, giving strong context for when to use it. However, it does not explicitly name alternative tools to use for other operations (e.g., modifying contacts in the list) or provide 'use this instead' guidance.

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

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

The description adds key behavioral context beyond annotations: it emphasizes that the research is asynchronous and that polling is required. It also mentions external sources (LinkedIn). However, it does not disclose other behavioral traits such as potential costs, failure modes, or the option to receive webhook notifications (a parameter in the schema). Annotations already indicate non-read-only and non-idempotent, so there is no contradiction, but the description could provide more depth on side effects.

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 sentence that front-loads the primary purpose, then adds the crucial follow-up action. Every clause earns its place, with no wasted words. It is concise yet informative.

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

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

The description provides a sufficient mental model: start async research, receive an ID, poll for results. Given the rich schema with all parameters documented, the description does not need to explain input details. It is slightly incomplete by not mentioning the webhookUrl alternative for completion notifications, but the schema covers that, so the overall context is reasonably complete.

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

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

Schema description coverage is 100%, with each parameter having a clear description and example. The tool description does not add parameter-level meaning beyond the schema, but it reinforces the need for contact and company information. Since the schema carries the full burden, a 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's purpose: 'Start asynchronous AI research for a contact using LinkedIn and other sources'. It specifies a distinct verb ('Start') and resource ('asynchronous AI research for a contact'), and differentiates from siblings like contacts-get_research by implying that this tool initiates research rather than retrieving results. The mention of 'poll the research ID' further distinguishes it as a kickoff action.

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

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

The description provides clear context: use this tool to start asynchronous research, then poll the returned ID for results. This implies the workflow and points to a separate polling step (likely via contacts-get_research). However, it does not explicitly name alternative tools or state conditions when not to use it, so it misses explicit 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 indicate this is a non-read-only, non-idempotent operation. The description adds valuable behavioral context by revealing the async pattern (immediate return, polling or webhook), which is not captured in the annotations. This exceeds the baseline while not over-explaining.

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, concise sentence that front-loads the action and conveys the essential workflow without any redundant information. It is perfectly sized for the tool's purpose.

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

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

The description covers the core workflow needed to use the tool effectively: create, get immediate response, and retrieve results via polling or webhook. Given the rich schema and annotations, it is complete enough, though it does not explicitly mention that the returned signal ID can be used with contacts-get_signal.

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 fully documents all parameters. The description adds no parameter-specific meaning beyond what the schema already provides, matching 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 uses a specific verb and resource ('Create a contact research signal') and clearly distinguishes this from sibling tools like 'contacts-get_signal' by stating it creates rather than retrieves. It also conveys the asynchronous nature, making the tool's 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?

The description explains the asynchronous workflow (return immediately, then poll or webhook), which implies when to use this tool versus synchronous alternatives. However, it does not explicitly name alternatives or state when to prefer this tool over others like 'contacts-create_research' or 'contacts-get_signal'.

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=false and destructiveHint=false, which is consistent with the 'enrich' action. However, the description adds no behavioral context beyond that—it does not mention caching, asynchronous processing, credit usage, or that it generates a signal. The schema's parameter descriptions contain such details, but the description itself fails to disclose any of these traits.

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 concise sentence that efficiently communicates the core action. It is not padded with fluff and is easy to parse. However, it is arguably too minimal, missing useful qualifiers like 'creates a signal' or 'for a contact', which would improve clarity without sacrificing conciseness.

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

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

The schema provides rich parameter-level context (e.g., forceRefresh, webhookUrl, verificationMode), but the tool has no output schema and the description does not explain what the tool returns or that it triggers asynchronous enrichment. Given the tool's complexity, a brief statement about the outcome or processing model is missing, making the description only partially 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 covers 100% of parameters with detailed descriptions, examples, defaults, and enums. The description itself adds no parameter-specific information. Per the rubric, with high schema coverage, a baseline score of 3 is appropriate since the schema already carries the semantic weight.

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 'Enrich a contact with a custom question' clearly identifies the action (enrich) and the resource (contact), and the 'custom question' aspect distinguishes it from other contact enrichment tools like work-email enrichment. However, it does not explicitly mention that it creates a signal or how it relates to similar sibling tools like contacts-create_signal, leaving some ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives such as companies-enrich_custom or contacts-create_signal. It does not mention prerequisites, exclusions, or scenarios where another tool would be more appropriate. The only implicit context is the 'custom question' differentiator, which is not enough for clear usage decisions.

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 no behavioral context beyond the annotations. It does not disclose that the operation is not read-only (readOnlyHint: false), nor does it mention potential outcomes like not_found, domain resolution behavior, or rate limits. The annotation says it's not read-only, but the description's 'find' wording may mislead agents into thinking it's a pure lookup without side effects.

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 concise sentence that gets straight to the point. It is front-loaded and contains no unnecessary words, earning a high score for conciseness.

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

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

Given the tool's complexity (4 parameters, no output schema, non-read-only behavior), the description is incomplete. It doesn't explain what the tool returns (e.g., email or not_found), when to use it alongside siblings, or any behavioral caveats. The schema covers parameters, but the tool-level 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 baseline is 3. The description itself adds no parameter details, but the schema already thoroughly documents each parameter, including domain normalization, full_name parsing, and company_name usage, so the baseline 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 'Find a contact's verified work email' clearly states the action (find) and the resource (verified work email). It is specific and distinguishes this tool from generic enrichment tools like 'contacts-enrich_custom' by emphasizing the verified work email output.

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. It does not mention any sibling tools, exclusions, or specific scenarios, leaving the agent without explicit usage context beyond the basic purpose.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds that it returns 'current status and AI-generated insights' and a completion condition, but does not disclose error behavior, polling semantics, or what happens before completion. Beyond annotations, limited additional disclosure, so 3.

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?

A single, front-loaded sentence that introduces the verb and object immediately and has no redundant phrases. Efficient for a one-parameter getter, so 5.

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 get-by-ID with no output schema, the description provides a high-level return summary but omits important context: what happens if the job hasn't completed, whether not-found errors occur, or the structure of insights. Given the openWorldHint and lack of output schema, more detail would help, but the description is minimally adequate, so 3.

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 one parameter with full description coverage (100%). The description's 'job' term aligns with schema's 'request' but adds no format, allowed values, or relationship details. Baseline 3 applies because schema carries the semantic weight.

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 a specific action (retrieve) and resource (contact research job), with a scoping condition ('when it has completed'). It distinguishes from write tools like contacts-create_research but does not explicitly differentiate from the similar sibling getContactResearchByExternalID, since both retrieve research data. Thus 4.

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

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

Provides a timing guidance ('when it has completed') that implies it should be called after completion, but does not name alternatives such as contacts-create_research or getContactResearchByExternalID, nor state when not to use it. Minimal guidance, so 3.

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 disclose readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds the completion condition and return content, but does not detail what happens if the signal hasn't completed or any error behavior, providing only marginal context beyond annotations.

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

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

The description is a single, well-structured sentence that front-loads the operation and includes only essential details, with no redundancy or filler.

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

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

For a simple one-parameter get tool with strong annotations, the description conveys the essential return value ('status and AI-generated answer') and call timing. The only notable gap is ambiguity about behavior when the signal is not yet completed, but overall 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 schema description for signalId is 100% complete, including UUID format. The tool description adds no further parameter meaning, so the baseline 3 applies.

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

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

The description uses a specific verb 'retrieve' and identifies both the resource ('contact signal') and the content ('current status and AI-generated answer'). It clearly distinguishes from sibling tools like contacts-list_signals or contacts-create_signal, which handle listing or creation rather than single retrieval.

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

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

The phrase 'when it has completed' provides a clear temporal context for when to invoke the tool. It implies the tool is meant to be called after a signal finishes, but it does not explicitly name alternatives or state when not to use it, stopping short of the highest tier.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, establishing the safety profile. The description adds minimal behavioral context beyond the action of listing, and does not mention return format, rate limits, or other operational traits. Since the bar is lower with annotations, this scores a 3.

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, front-loaded sentence with no filler. Every word contributes to conveying the action and key options, 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?

The tool is simple with three optional parameters and no output schema. The description, while minimal, clearly indicates the list action and available filtering, which is sufficient for an agent to invoke it. However, it could have explained what a 'signal run' is or what the response looks like, given no output schema exists.

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

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

Schema description coverage is 100%, with all three parameters (limit, offset, contactProfileUrl) documented. The description merely summarizes them as 'optional filters for profile URL and pagination,' adding no additional semantic meaning beyond what the schema provides. Baseline 3 applies.

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

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

The description uses the specific verb 'List' with the resource 'contact signal runs,' clearly distinguishing it from other list tools like company_signals-list or market_signals-list_signals. It also notes the optional profile URL filter, which ties to contacts, 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 implies usage when one needs to list contact signal runs and mentions optional filters, but it does not explicitly state when to choose this over alternatives or mention any prerequisites. There is no comparison with sibling tools, so guidance is only implied.

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

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

The description adds the significant context that the search runs through the API key owner's Sales Navigator connection, which implies network-dependent results. Given the annotations already provide readOnlyHint=false, openWorldHint=true, etc., this extra context is helpful, though it does not disclose potential side effects like credit consumption or rate limits; it does not contradict annotations.

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

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

The description is a single, focused sentence that immediately states the tool's purpose and key search dimensions. No filler or repetition – it 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?

For a tool with a rich schema covering pagination, filters, and error handling, the description provides the essential overview (what it searches and via whose connection). It lacks an explicit statement of return values, but the schema's references to 'contacts' and pagination imply the output; the description is adequate given the schema's depth.

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 describes all parameters exhaustively (100% coverage), so the description adds only a high-level mapping of search criteria to parameters. It provides no additional semantic detail beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Search') and resource ('contacts') and enumerates the searchable attributes (company, name, job title, keyword, country, department, seniority), clearly distinguishing it from sibling tools like company_lists-search (company lists) or contacts-get_research (research profiles).

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

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

The description gives clear context for when to use the tool (when you need to find contacts by those criteria and have the API key owner's Sales Navigator connection), but it does not explicitly state alternative tools or exclusions, so it stops short of full guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds valuable behavioral context by specifying the temporal scope ('current billing period'), which is not encoded in the annotations. No contradictions detected.

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, front-loaded sentence with the verb 'Check' first. It contains no filler or redundancy, earning a perfect conciseness score.

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, no output schema, and rich annotations, the description adequately conveys the purpose and the nature of the return value ('how many credits left'). It could specify the exact response format, but the phrase implies a numeric value, which is sufficient for this simple read-only 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?

With zero parameters, the baseline is 4 per the rubric. The input schema is empty, and the description correctly implies no inputs are required. No additional parameter explanations are needed.

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

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

The description uses a specific verb ('Check') and identifies the exact resource ('Saber API credits') with a scope ('current billing period'). It clearly distinguishes itself from sibling tools, none of which relate to credits or billing.

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

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

The description provides clear context about what is being checked (credits remaining in the billing period) but does not explicitly mention when to use this tool versus alternatives. Since there are no sibling tools for credits, the usage context is sufficient, but explicit exclusions are absent.

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 no behavioral information beyond the annotations. The annotations already indicate read-only, idempotent, and non-destructive behavior, but the description does not disclose what happens if the run is not found, whether it returns full details, or any other runtime behavior. It relies entirely on structured annotations.

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

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

The description is extremely short ('Get an enrichment run'). While it is concise, it is under-specified rather than appropriately concise. It lacks critical details that would make the single sentence useful, such as the key parameter or return behavior. This is similar to the 'Process' example where brevity masks incompleteness.

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 (one parameter, no output schema, clear safety annotations), one might expect a simple description, but this is too minimal. It does not describe what the output looks like, possible error conditions, or how the run ID is used. The annotations and schema do not compensate for the lack of contextual detail. A complete description would at least mention 'by runId' and summarize what an enrichment run is.

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 0% for the single parameter runId. The description does not explain what runId refers to, how to obtain it, or its format/constraints. With such low schema coverage, the description must compensate but offers no parameter-related information at all. The parameter name is partially self-explanatory, but the description itself adds no semantic value.

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

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

The description 'Get an enrichment run' clearly states the action (get) and the resource (an enrichment run). It is understandable but does not explicitly distinguish from the sibling tool enrichment_runs-list, which also deals with enrichment runs. The verb 'get' implies a single item retrieval, but no mention of by ID or that this is for a specific run vs listing all runs.

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?

There is no guidance on when to use this tool versus alternatives. It does not mention that it retrieves a single run by runId, nor does it reference sibling tools like enrichment_runs-list for listing. No context is provided about typical use cases or prerequisites.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the base safety profile is known. However, the description adds no behavioral context such as pagination behavior, default sort order, or that it returns only a subset of runs. It fails to disclose anything beyond what annotations already convey.

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

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

The description is a single short sentence with zero fluff, which is highly concise. It earns a 4 for efficiency, though the brevity does sacrifice completeness.

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

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

With 8 parameters, no output schema, and only a one-line description, the context is severely lacking. The description does not explain what an enrichment run is, how results are filtered or ordered, or what the response contains, making it insufficient for an agent to invoke the tool correctly without external knowledge.

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 description mentions none of the 8 parameters. Schema description coverage is 63%, meaning some parameters like `limit`, `offset`, and `entityType` lack textual descriptions. The description does not compensate for this gap, leaving those parameters semantically underdocumented.

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 ('List') and resource ('enrichment runs'), making the purpose unambiguous. While it doesn't explicitly distinguish from sibling tool `enrichment_runs-get`, the verb 'list' implies a collection operation. It is specific but could benefit from mentioning filtering scope.

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

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

No guidance is provided on when to use this tool versus alternatives like `enrichment_runs-get` or `enrichment_templates-list`. The name implies it is for listing multiple runs, but the description offers no explicit context or 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?

The description adds no behavioral details beyond the bare action. Annotations provide non-idempotent and non-read-only hints, but the description does not mention return values, side effects, or any required permissions. It is essentially a restatement of the tool name.

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, very short sentence with no wasted words. However, it is under-specified for the tool's complexity, providing almost no informative content beyond the tool name, so it is not effectively structured for an agent.

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

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

The tool has a complex schema with nested objects, conditional fields like outputSchema and qualificationCriteria, and no output schema. The description fails to convey the template's purpose, relationship to enrichment runs, or any usage context, leaving the agent without enough grounding to select it appropriately.

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

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

The input schema has 100% coverage with detailed descriptions, examples, and conditional requirements for each field. The tool description adds no parameter information, so the schema carries the full burden, matching the baseline for high 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 'Create an enrichment template' uses a clear verb and resource, distinguishing it from sibling CRUD operations like get, update, and delete. However, it does not explain what an enrichment template is or how it differs from others like signal templates, so it's not fully specific.

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

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

There is no guidance on when to use this tool versus alternatives. No mention of prerequisites, typical scenarios, or contrast with enrichment_templates-update or signal_templates-create. The CRUD sibling set implies usage, but the description itself gives no 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 indicate destructiveHint: true, but the description adds no context about consequences such as whether the deletion is permanent, whether related data is cascaded, or any required permissions. No additional behavioral traits are disclosed beyond the action itself.

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 concise sentence, front-loaded with the action and resource. It contains no redundant or filler words, though it is arguably too sparse to fully inform an agent.

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

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

For a destructive tool with no output schema, the description is too minimal. It fails to mention the outcome of a successful deletion, behavior when the template does not exist, or any side effects, leaving informational gaps that annotations alone do not fill.

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 no description for templateId, and the tool description does not compensate. It doesn't mention that the parameter identifies which template to delete, leaving the agent to infer this from the tool name and schema property name. Parameter semantics are not enriched beyond the schema.

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

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

The description uses the specific verb 'Delete' with the resource 'enrichment template', clearly distinguishing it from the sibling tools that create, get, list, or update enrichment templates. It is direct and 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 provides no guidance on when to use this tool vs alternatives. It simply restates the action implied by the name, with no mention of prerequisites, exclusions, or cases where a different tool (e.g., update or get) would be more appropriate.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description itself adds no behavioral context beyond these hints—no mention of return values, error handling, or permissions—so it provides little value beyond the structured annotations.

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

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

The description is a single, succinct sentence with no unnecessary words. It is front-loaded and efficient, perfectly serving its purpose without filler.

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

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

Given the tool's low complexity (one parameter, no nested objects, safe annotations), the description is minimally adequate. However, with no output schema, some context about the response or the nature of enrichment templates would improve completeness. It is functional but sparse.

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 0% description coverage, and the description does not mention the templateId parameter. While the parameter name is self-explanatory as an identifier, the description adds no explanation of what the parameter is for or how to use it, failing to compensate for the missing 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 'Get an enrichment template', using a specific verb and resource. It accurately conveys the tool's function, but does not differentiate from sibling tools like enrichment_templates-list or provide any detail about what an enrichment template is.

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 given on when to use this tool versus similar operations like enrichment_templates-list (to fetch multiple templates) or enrichment_templates-get variations. The description provides no context on prerequisites or scenarios, leaving the agent to infer usage solely from 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no extra behavioral context such as pagination behavior, default ordering, or whether deleted templates can be included. Since the annotations are strong, a neutral description earns a baseline 3; no contradiction exists.

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 sentence with no unnecessary words. It is front-loaded and immediately states the action and resource. There is no wasted content, making it optimally 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?

With no output schema, the description should help the agent understand what the response looks like, but it does not. It also omits pagination details (limit/offset) and the option to include deleted templates, both of which are part of the tool's behavior. While annotations clarify safety, the description lacks enough information about usage nuances and expected return shape for a complete picture.

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 only 33% (only includeDeleted has a description). The tool description does not compensate for the missing descriptions of limit and offset, nor does it mention pagination or the includeDeleted option. It adds no meaning beyond the schema fields, which are already sparse. The agent must infer the semantics of limit/offset from defaults and ranges 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 'List enrichment templates' uses a specific verb ('List') and a clear resource ('enrichment templates'), making the primary purpose obvious. It distinguishes from sibling CRUD operations like enrichment_templates-get (which implies fetching a single item) and create/update/delete. However, it does not explicitly mention pagination or filtering, but the verb and resource are clear enough.

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. It does not mention that this is for listing all templates, or when to use enrichment_templates-get for a specific template, or how it differs from enrichment_types-list. No exclusions or alternatives are stated, so the agent is left without decision-support information.

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 no behavioral information beyond what annotations already provide. It does not mention whether updates are partial or full replacements, whether existing data is overwritten, any side effects, or whether the operation is reversible. Annotations indicate it is not read-only and not idempotent, but the description contributes no additional context, earning a low score.

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?

While the one-sentence description is concise, it is under-specified rather than appropriately sized. It conveys no actionable information and does not earn its place because it merely restates the tool's name. This is a case of under-specification, not effective conciseness.

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

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

The description is completely inadequate for a tool with nested objects, multiple optional fields, and no output schema. It gives no indication of update semantics (e.g., partial vs. full replacement), required vs. optional fields, or the consequences of an update. The agent is left with almost no context to make an informed decision, making this a very incomplete definition.

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 description does not mention any parameter, even though the schema has a nested __requestBody object with multiple fields. Schema coverage is moderate (50% at the top level) with many subfields described, but the description fails to clarify that templateId identifies which template to update or that __requestBody contains the mutable attributes. Thus the description adds no 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 'Update an enrichment template' is essentially a restatement of the tool name 'enrichment_templates-update'. It identifies the verb and resource but provides no additional specifics about what updating entails, how it differs from creating or deleting, or what fields are involved. It is a tautology rather than a useful purpose statement.

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 offers no guidance on when to use this tool versus alternatives like enrichment_templates-create or enrichment_templates-delete. There are no prerequisites, no context about typical scenarios, and no explanation of how updates fit into the overall workflow. Usage is not implied beyond the basic meaning of 'update'.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, which fully cover the safety profile. The description adds no extra behavioral context, but it is consistent with annotations, so a baseline score is appropriate.

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

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

The description is a single, concise sentence that is front-loaded and contains no wasted words. It is appropriately sized for a simple list 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 zero-parameter list tool with comprehensive annotations, the description is mostly complete. However, it does not explicitly describe what 'enrichment types' are or what the return value looks like, which would be useful given no output schema. As it stands, the name and minimal description are sufficient for the likely use case.

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 tool has zero parameters, so the input schema is trivially complete (100% coverage). Per the scoring guidelines, the baseline is 4 when there are no parameters; the description does not need to add parameter semantics.

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

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

The description 'List enrichment types' uses a specific verb ('list') and a distinct resource ('enrichment types'), clearly stating the tool's function. It differentiates from sibling list tools by the unique resource type, 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 provides no guidance on when to use this tool versus alternatives. It does not mention scenarios, exclusions, or relationships to other enrichment-related tools, leaving the agent without context for selection.

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

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

Annotations include openWorldHint=true and readOnlyHint=false, but the description adds the behavioral trait 'verified', indicating the tool performs verification steps. However, it does not disclose potential outcomes (e.g., no email found) or side effects.

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, front-loaded sentence with no wasted words. It is appropriately concise, though extremely brief. It lacks any formatting issues.

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

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

No output schema exists, yet the description implies the return value (a verified email). The rich parameter descriptions compensate for some complexity, but the description does not explain error cases or the absence of a result. It is adequate for a simple lookup but leaves 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% and parameter descriptions in the schema are very detailed (domain formats, name cleaning, redirects). The tool description itself adds no additional parameter meaning, matching 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 verb ('Find'), the resource ('verified email address'), and the target ('for a contact at a domain'). It effectively distinguishes from siblings like findEmailBatchGet by implying a single lookup, matching the tool name.

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 use for a single email lookup but does not explicitly mention when to prefer this over batch tools (e.g., findEmailBatchSubmit) or any alternatives. No when-not guidance is provided.

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

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

The annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds little behavioral context beyond the resource name; it doesn't explain polling semantics, response format, or retry recommendations. No contradiction with annotations.

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

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

The description is one short sentence, front-loaded with the verb and resource. It is concise but not overly terse; it conveys the core action without excess 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?

With no output schema and a minimal description, the tool lacks explanation of what a 'poll' returns (status vs. results), or how to interpret the response. The parameter description provides some context but the description as a whole is incomplete for a tool involved in an async workflow.

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 the single `id` parameter, and its description explains it's a batch ID from a submit call. The tool description itself adds no parameter details, but the baseline is 3 due to 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 uses the verb 'Poll' and identifies the resource as a bulk find-email batch, distinguishing it from sibling tools like findEmailBatchSubmit and findEmail. However, it doesn't specify whether it returns status only or final results, making it slightly vague.

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 vs alternatives. It doesn't mention that this should be called after findEmailBatchSubmit, or that it's for retrieving async results. The parameter schema mentions 'returned by the submit call', but that is in the schema, not the tool description.

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 non-read-only, non-idempotent, non-destructive, and open-world behavior. The description adds no extra context such as async processing, returned batch ID, or the need to poll for results, which is important for a submit action.

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, concise sentence that is front-loaded with the key verb and object. No filler or redundant information.

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

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

For a bulk submit operation with no output schema, the description fails to explain what the response will contain (e.g., a batch ID), how to retrieve results, or any async/workflow details. This leaves a material gap for the agent to invoke and use the tool correctly.

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

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

Schema description coverage is 100% at the top level, though the field descriptions are minimal ('Same semantics as the single find-email endpoint'). The tool description adds no parameter detail beyond what the schema provides, so the baseline 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 action ('Submit') and the resource ('a bulk find-email batch'). It distinguishes this tool from siblings like findEmail (single lookup) and findEmailBatchGet (retrieving batch results).

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 vs. alternatives. It does not mention that findEmail is for single requests, findEmailBatchGet for pulling results, or any prerequisites or next steps.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description aligns with these. The description adds minimal behavioral context beyond the annotations, such as the requirement for both external ID and source name, but does not disclose return format, error cases, or other operational traits.

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 concise sentence, front-loaded with the action and resource, and includes a concrete example. No wasted words.

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

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

Given the tool's simplicity (2 params, read-only, no output schema), the description is adequate for understanding what it does and the key parameters. It might benefit from a note about return content, but the low complexity and strong annotations make this a minor gap.

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

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

Schema description coverage is 100% with both parameters well-described. The description essentially repeats the schema examples (HubSpot contact ID, source name) without adding further meaning or clarifying relationships between parameters.

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

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

The description clearly states the tool retrieves contact research using an external system ID and source name, with a specific verb and resource. It does not explicitly distinguish from sibling tools like contacts-get_research, though the external ID focus adds some 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 when an external ID (e.g., HubSpot contact ID) is available, but provides no explicit guidance on when to avoid this tool or use an alternative. There are no references to sibling tools or exclusions, so guidance is implied rather than stated.

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

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

Annotations already indicate this is a write operation (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds the scope of monitored signals but does not disclose idempotency (already idempotentHint=false), response behavior, or that webhooks will be sent. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence that directly states the action and scope. It contains zero wasted words and is easy to parse.

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

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

For a complex create operation with a nested filter schema and no output schema, the description is quite thin—it doesn't mention required fields (type, webhookUrl) or that filters vary per signal type. However, the extremely detailed input schema carries most of the burden, so the short description is not severely deficient. It could mention expected response or side effects (e.g., subscription becomes active).

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 detailed descriptions for __requestBody, type, filters, webhookUrl, interval, and other fields. The description adds no parameter-level guidance, relying entirely on the schema, so the 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 uses a specific verb ('Create') and resource ('market signal subscription'), and enumerates the monitorable signal types (job posts, LinkedIn posts, fundraising, investments, IPOs). This clearly distinguishes it from sibling operations like market_signals-get_subscription or company_signals-create.

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 setting up market-signal monitoring but provides no explicit guidance on when to choose this over alternatives (e.g., company_signals-create) or what prerequisites exist (e.g., a webhook URL is required). The enumerated signal types give partial context, but there are no when-not-to-use instructions.

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

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

The description simply restates the deletion action and adds no behavioral traits beyond the annotations. It is consistent with the annotations (destructiveHint=true, idempotentHint=true) and does not contradict them, but it offers no extra context such as irreversibility or side effects.

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 one short, direct sentence that is easy to scan. It contains no unnecessary words and delivers the key information immediately.

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 single-parameter delete operation with strong annotations, this is nearly sufficient. It could mention side effects or return values, but the low complexity and the presence of destructiveHint and idempotentHint cover most concerns.

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 subscriptionId is fully documented in the schema with a clear description ('The unique identifier of the subscription to delete'). With 100% schema coverage, the description does not need to add parameter semantics.

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

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

The description uses a clear verb ('Delete') and a specific resource ('market signal subscription'), making the tool's purpose unambiguous. It is clearly distinct from sibling tools like market_signals-create_subscription, market_signals-get_subscription, and market_signals-update_subscription.

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, nor any preconditions or consequences. It relies entirely on the tool name and sibling context, giving the agent no explicit direction.

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, and the description's 'Get' aligns with these. The description adds no new behavioral context such as error behavior, ownership semantics, or return format. No contradiction exists.

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 six-word sentence, front-loaded with the verb and object, and contains no filler or redundant detail. It is an ideal length for this simple retrieval 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 single-parameter, read-only get-by-ID tool with rich annotations, the description is nearly complete. It could mention what the response contains or explicitly point to list_subscriptions for enumeration, but the current text is sufficient for an agent to invoke the tool correctly.

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

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

The input schema already provides full documentation for subscriptionId with a clear description and UUID format, and the description just restates 'by ID' without adding further semantics. Since schema description coverage is 100%, the 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?

Description uses the specific verb 'Get' and identifies the resource as 'a market signal subscription by ID', clearly distinguishing it from sibling list_subscriptions and other market signal operations. The scope is unambiguous and aligns with the tool name.

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 phrase 'by ID' implies the tool should be used when the caller already has the subscription ID, but there is no explicit guidance about alternatives such as list_subscriptions for discovering subscriptions or when not to use this tool. Usage context is present but only implicit.

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=true, destructiveHint=false, idempotentHint=true) already establish the safety profile. The description adds the subscription scoping but no extra behavioral details about return format, ordering, or pagination behavior beyond what the schema provides.

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 concise sentence that states the action directly with no unnecessary words or repetition.

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 paginated list operation with good annotations and full schema coverage, the description is largely complete. However, the absence of an output schema and any explicit note about the response structure leaves minor ambiguity about what exactly is returned.

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

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

The input schema provides full descriptions for all three parameters (subscriptionId, limit, offset), achieving 100% schema description coverage. The description adds no additional parameter semantics, so the baseline 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 uses the specific verb 'List' and clearly identifies the resource as 'signals delivered by a market signal subscription.' This distinguishes it from sibling tools like market_signals-list_subscriptions (which lists subscriptions) and company_signals-list (which lists company signals).

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: you would call this when you have a market signal subscription and want its delivered signals. However, it does not explicitly state when to use this tool over alternatives or provide any 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no additional behavioral context beyond the annotations, such as pagination behavior or default exclusion of deleted items (though the includeDeleted parameter hints at this).

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, clear sentence with no filler. It is front-loaded with the verb and resource, achieving maximum conciseness.

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

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

For a simple list tool with comprehensive annotations and schema coverage, the description is adequate but not complete. It omits mention of pagination behavior or potential distinctions from similar sibling tools, and the use of 'all' could be misleading given the limit/offset parameters.

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%; all three parameters (limit, offset, includeDeleted) are already well-documented in the schema. The description does not add further insight into parameter usage or edge cases.

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 ('List') and the resource ('market signal subscriptions'), with an explicit scope ('for your organization'). It effectively distinguishes from sibling tools like market_signals-get_subscription by being the list counterpart.

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. Sibling tools such as signal_subscriptions-list or company_signals-list could cause confusion, and there is no mention of when to prefer this tool over them or when not to use it.

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 no behavioral context beyond the annotations. It does not explain what pausing entails (e.g., whether it stops data collection or billing, whether it is reversible, or any side effects). It essentially repeats the tool name without providing additional 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, concise sentence with no wasted words. However, it is almost a tautology of the tool name and provides no additional informative value, placing it at the minimum viable level for conciseness.

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

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

For a mutation tool with no output schema and minimal description, the context is incomplete. The description does not mention the relationship to resume_subscription, the effects of pausing, or any prerequisites. Given the simplicity of the tool, a slightly richer description would be expected to fully understand the operation's impact.

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 for the single parameter subscriptionId, and the parameter description is clear. The tool description itself adds no parameter-level detail, but the baseline of 3 applies because the schema fully documents the parameter.

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

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

The description clearly states the verb 'Pause' and the resource 'market signal subscription', distinguishing it from sibling tools like resume_subscription and delete_subscription. It precisely identifies the action and the object.

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. It does not mention related actions like resume, delete, or update, nor does it indicate situations where pausing is appropriate.

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

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

The description adds no behavioral information beyond what annotations already state. Given openWorldHint=true and idempotentHint=false, the description should mention potential side effects (e.g., resuming signal delivery and possible credit usage) or error conditions, but it remains silent.

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, front-loaded sentence containing only essential words. Every word earns its place, and there is no redundant or fluff 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?

Although the tool is simple (one param, no output schema), the openWorldHint and the presence of many sibling subscription tools demand more context. The description lacks explanation of side effects, prerequisites, or how it differs from similar unpause/start tools, making it incomplete for safe invocation.

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

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

The input schema already provides full documentation for subscriptionId ('The unique identifier of the subscription to resume'), covering 100% of parameter semantics. The tool description adds no additional parameter information, matching 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 'Resume a paused market signal subscription' clearly identifies the action (resume) and the resource (paused market signal subscription). The inclusion of 'paused' differentiates this from pause, create, delete, and other sibling operations, 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 word 'paused' implies the tool should be used when a subscription is in a paused state, providing minimal contextual guidance. However, there is no explicit mention of prerequisites (e.g., the subscription must exist) or alternatives like subscription_actions-unpause or signal_subscriptions-start, leaving room for confusion.

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 this is a non-read, non-destructive, non-idempotent action. The description adds only 'immediate run', which mainly restates the name, and discloses no side effects, result format, or asynchronous behavior.

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

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

The description is a single sentence, front-loaded with the action and object, and contains no unnecessary words. It is appropriately sized for a simple one-parameter tool.

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

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

The tool has only one parameter and no output schema, and annotations provide basic safety context. However, the description lacks information about return behavior, side effects of triggering, or whether the run is synchronous—leaving some gaps for an agent.

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

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

Schema description coverage is 100% for the single parameter, which is fully documented with type, format, and description. The tool description adds no extra parameter detail, 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 uses a specific verb ('Trigger') and resource ('market signal subscription'), clearly distinguishing it from sibling tools like pause/resume/update. It also adds the qualifier 'immediate run' to specify the action's nature.

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

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

No explicit guidance is given on when to use this tool versus alternatives. It does not mention prerequisites, scheduling behavior, or cases where another tool (e.g., pause/resume) would be more appropriate.

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

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

Annotations already indicate this is a non-read-only, non-destructive, non-idempotent operation. The description adds no extra behavioral context such as field mutability, side effects on polling, authentication needs, or what happens to the existing subscription.

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 one short sentence with no fluff or wasted words. However, it largely restates the tool name and does not earn its place by adding new information, making it minimally acceptable but not notably concise in a valuable way.

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

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

The schema and annotations provide enough structured information for invoking the tool, but the description lacks usage guidance and behavioral context. Given the complexity of the nested request body and the large set of sibling tools, more context would be needed for a fully complete description.

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

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

Schema description coverage is 100%, with detailed descriptions for subscriptionId and every request body field, including behavior like 'Changing this restarts the polling schedule.' The description adds nothing beyond the schema, so the baseline 3 applies.

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

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

The description states a clear verb and resource: 'Update a market signal subscription'. This distinguishes it from create/delete/list operations, but it does not differentiate between market_signals-update_subscription and the closely named sibling signal_subscriptions-update.

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 given on when to use this tool versus market_signals-pause_subscription, market_signals-trigger_subscription, signal_subscriptions-update, or other subscription management tools. No context, prerequisites, or exclusions are provided.

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

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

The description adds no behavioral context beyond the annotations; it does not mention side effects, prerequisites, or response behavior. Annotations indicate readOnly=false and destructive=false, but the description doesn't clarify what creating a monitor entails, such as whether it requires an existing list or how the webhook/schedule interact.

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 short sentence, but it is tautological and under-specified rather than appropriately concise. It does not earn its place because it adds no information beyond the tool name.

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

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

The tool has a highly complex nested request body (checks with kinds, target types, webhook, schedule) and no output schema, yet the description provides zero context about how to structure a valid request or what the tool accomplishes beyond the verb phrase. This is completely inadequate for the complexity involved.

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 reported at 100%, and the schema itself documents most fields (e.g., check type, prompt, templateId, entity, secret, cronExpression). The description contributes nothing about parameters, but the baseline is 3 because the schema carries the semantic weight.

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 'Create a monitor' directly restates the tool name 'monitors-create' with no added specificity. It does not distinguish this tool from siblings like monitors-create_action or company_signals-create, and fails to indicate what type of monitor is created or what makes it unique.

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 such as monitors-create_action, monitors-update, or signal_subscriptions-create. The description is a bare command with no context, prerequisites, or exclusion criteria.

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

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

The annotations already indicate readOnlyHint=false and openWorldHint=true, so the description doesn't need to restate that this is a write operation with external effects. However, it adds no further behavioral context, such as that this creates a webhook action or what side effects may occur.

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, a single front-loaded sentence that clearly states the action. It contains no filler, earning a high score despite being minimal.

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 a nested request body, no output schema, and a rich sibling context, the description is too sparse. It does not explain what a monitor action is, why or when to create one, or what the webhook does, leaving agents to rely entirely on schema details.

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 description does not explain any parameters, but the input schema covers key semantics: monitorId is a UUID, and __requestBody constrains type to 'webhook' with a destination URL. With 50% schema description coverage, the schema carries most of the burden, so the lack of description is acceptable but not ideal.

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 'Create a monitor action' uses a specific verb (create) and resource (monitor action), distinguishing it from sibling tools like monitors-update_action or monitors-delete_action. However, it doesn't clarify what a monitor action entails (e.g., webhook delivery), so it's clear but somewhat shallow.

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 usage guidance is provided. The description does not state when to use this tool, prerequisites (e.g., an existing monitor), or alternatives. It also doesn't differentiate itself from the many other action-related tools in the sibling list.

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

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

Beyond the annotations (destructiveHint=true, idempotentHint=true), the description adds no behavioral context. It does not disclose permanence, cascading effects on related resources, or any state requirements. With annotations covering the safety profile, the description contributes nothing additional.

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, concise sentence with no redundant words. It is front-loaded and easy to parse. However, its brevity approaches under-specification, though it remains clear and efficient.

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

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

The tool has a simple interface with one parameter and no output schema. Annotations provide safety information, but the description lacks any detail about what happens after deletion (e.g., response format, side effects on associated actions). Given the low complexity, it is minimally viable but not complete.

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