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 declare non-read-only, open-world, non-idempotent, non-destructive, and the description adds key behavior beyond them: per-domain run creation, a 100-target cap, immediate 202 response, and polling via enrichment_runs-get/list. Missing permission/cost details, but strong operational disclosure.

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

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

Four sentences, front-loaded with purpose and scope; each sentence carries operational information about cap, async behavior, or polling. No 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 complex asynchronous batch write with rich schema and annotations but no output schema, the description supplies the needed execution model: cap, 202, and how to retrieve runs. It could mention auth/credit implications, but core call-completeness is adequate.

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

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

Schema coverage is high, so the schema documents most fields. Description adds batch semantics by tying the question to all targets and reinforcing the 100-target limit from the schema, though it does not explain the many other optional configuration 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?

States a specific verb 'Enrich' and resource 'companies' with batch scope 'many' and 'one shared custom question,' distinguishing it from the single-company sibling companies-enrich_custom. An agent can identify batch custom enrichment immediately.

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?

Explains the batching context: use when enriching many companies with one shared custom question, and split larger lists into calls of 100 or fewer. It also directs polling after the call, though it does not explicitly name companies-enrich_custom as the single-company alternative.

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?

Beyond annotations, the description flags important runtime behavior: 'Branch on status', ambiguous candidates are alternatives rather than a ranked answer, and call can take up to four minutes. These are non-obvious details for an agent and are not available in the schema or 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 four short sentences with no filler or repetition. It fronts the core purpose, then the key use-case guidance, behavioral ambiguity handling, and the runtime constraint, with each sentence adding distinctive value.

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

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

Given there is no output schema, the description reasonably covers the critical behavior: resolution to domain, ambiguity handling, status branching, and timeout. It still leaves statuses values and output shape unspecified, but for a single-focused lookup tool it is sufficiently 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 already describes all parameters (100% coverage), so the default baseline is 3; nonetheless the description adds parameter-selection guidance by stating when to supply country and article context for ambiguous cases. It reinforces which optional fields matter and when, which is useful beyond the schema text.

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

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

The description uses a specific verb-resource pair ('Resolve a company name to its official domain') that clearly communicates the tool's unique purpose. This differentiates it from sibling enrichment tools such as companies-enrich_firmographics or companies-generate_summary, and no other sibling covers domain resolution.

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 concrete usage context: supply country and article context for ambiguous names, and treat ambiguous candidates as alternatives rather than a ranked result. It does not explicitly name alternatives or state when not to use this tool, but the tool's domain-specific purpose stands apart from the sibling set, making explicit exclusions less necessary.

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 presents a preview/estimation operation, which strongly implies read-only behavior, but the annotations declare readOnlyHint=false. This is an annotation contradiction. The description also does not explain whether credits are consumed by the preview itself, what side effects might occur, or how the open-world nature affects the estimate.

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 efficiently communicates the two key outputs: company count estimate and credit cost estimate.

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

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

Despite having no output schema, the description does not explain the return format or whether the tool returns both count and cost separately. It also omits when to use the preview versus actual list operations, and the readOnlyHint contradiction leaves behavioral expectations unclear. Given the nested filter complexity, more 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 coverage is 100%, and each filter property has its own description with examples. The tool description adds nothing beyond the phrase 'list filter,' so it does not improve on what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states a specific action (estimate) and resource (companies matching a list filter), and adds the unique aspect of credit cost estimation. This distinguishes it from sibling tools like company_lists-get_companies or company_lists-export, which perform actual retrieval/export operations.

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

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

The phrase 'would cost' implies this tool is meant to be used before an actual list operation to preview counts and credits, but it never explicitly says 'use before creating/exporting a list' or contrasts itself with alternatives. Usage context is only implied, not 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 declare the write profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true, idempotentHint=false). The description adds that the resulting list is reusable across multiple workflows, which is light extra context, but it does not disclose non-idempotent behavior (duplicate lists on repeat calls) or any limits on how many filters/lists can be saved.

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 commits the verb and resource immediately with no filler or repetition. Every clause earns its place by naming the use cases.

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 mutation with a deeply nested request body and no output schema, the description says nothing about what is returned (presumably a list object/ID) or about the __requestBody wrapper. Annotations cover safety, but the return/confirmation aspect is missing.

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

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

Schema description coverage is 100% and the nested filter object is thoroughly documented in the schema, so the schema does the heavy lifting. The description only refers generically to 'a company filter' and adds no syntax or field-level meaning beyond it, making the baseline 3 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?

States a clear verb ('Save') and resource ('a company filter as a reusable list'), and the company-list scope implicitly separates it from contact_lists-create and company_lists-update. It does not explicitly name or contrast with a sibling, so it stops short of 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 downstream purposes (review, enrichments, scoring, export, CRM workflows) imply why an agent would create a list, giving useful context. However, there is no explicit when-to-use vs. when-not, no prerequisites, and no mention of the update/import alternatives.

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

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

Annotations already declare 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 carry the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true). The description adds only that output is CSV, but says nothing about whether this is synchronous, whether large exports are paginated/async, whether the CSV is returned inline or via a download URL, or any rate limits — leaving real behavioral gaps despite the lower bar set 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?

A single sentence, front-loaded with the core action and output format, with the optional-field behavior trailing. Nothing redundant and no 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 an export tool with nested body params and no output schema, the description covers the essentials (what is exported, output format, optional column groups). It is slightly thin on how the CSV result is delivered and how the signal-template columns are named/derived, but the schema already explains the column rules, so the remaining gap is minor.

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 both parameters (listId, fields, signalTemplateIds) are already fully documented in the schema, including the 422 behavior and the two-columns-per-subscription rule. The description only loosely maps 'firmographic and enrichment columns' onto the two optional arrays, adding little beyond what the schema states, 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 specific verb (Export), resource (a saved company list), and output artifact (CSV), which cleanly distinguishes it from siblings like company_lists-get_companies (returns companies) and company_lists-count_preview (returns counts). An agent can identify this as the CSV-generation tool without opening any schema.

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

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

Usage is only implied: the mention of 'saved company list' and 'CSV' signals it is for extracting a list to a file, but there is no explicit when-to-use guidance, no mention of prerequisites (e.g., the list must exist), and no comparison against alternatives such as company_lists-get_companies.

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 adds a valuable behavioral trait beyond the annotations: the 50-result cap and the non-final 'preview' nature of the call. Annotations already provide safety-related hints (openWorldHint, destructiveHint), and while readOnlyHint=false is slightly awkward for a 'preview' operation, there is no direct contradiction.

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

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

A single, front-loaded sentence with no redundant words. It states the purpose, scope, limit, and intended position in the workflow 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 preview tool with a fully described filter schema, the description provides essential invocation context: what it does, the limit, and when to use it. Since there is no output schema, it could optionally describe the exact fields returned, but the core call context is complete.

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

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

The input schema already describes every filter field with 100% coverage. The description refers generically to 'a filter' and does not add parameter-level meaning beyond what the schema provides, so the 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 states a specific action ('Preview'), a clear resource ('companies'), and a concrete bound ('up to 50'). The phrase 'before creating a reusable company list' ties it to the company_lists workflow and differentiates it from both generic company search and the sibling count_preview tool.

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

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

Clear usage context is provided: use this tool to preview matching companies before creating a reusable company list. It does not explicitly name alternatives or exclusion conditions, so it stops short of a fully prescriptive when-to-use/when-not-to-use statement.

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, destructiveHint=false, idempotentHint=true, openWorldHint=true. The description adds one useful behavioral trait: it refreshes the cached matching companies after the update. However, it does not disclose side effects like whether the existing filter is fully replaced or merged, whether the cache refresh is async and eventual, or whether excluded companies are removed from list membership. With annotations covering little (this is a state-changing tool with only hints that it is non-destructive and idempotent), the description carries some burden and only partially meets it.

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?

One sentence, direct and efficient. The core action and the notable cache-refresh side effect are both included without fluff. Slightly more context on replace-vs-merge behavior would be useful but the sentence is earnestly compact.

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 is rich and fully documented, which covers parameter formatting. The tool has no output schema, so the agent does not know what the response looks like; the description does not mention the return value or eventual caching behavior. For an update operation this is adequate but not complete: an agent receiving a success/failure response might still not know when the cache refresh completes or how to verify the update took effect.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal extra meaning: it makes clear that name and filter are the updatable fields, but the schema already explains each field. It does not clarify how the filter parameter interacts with an existing filter (replace vs merge), which would add real semantic 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 states a specific verb ('Update'), a specific resource ('a company list'), and the two things being updated ('name or filter'). It also mentions refreshing cached matching companies, which is behavior specific to this tool. Among siblings like company_lists-create/delete/get, it's clearly distinguishable as the update operation.

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

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

The description implies the tool is for updating an existing company list's name or filter, and contrasts with create/delete/get via the verb. However, it provides no explicit when-to-use guidance, no mention that the listId must exist, no note about validation of filter criteria, and no direction to alternatives (e.g., use create for new lists, delete for removal). Minimum viable but thin.

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 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=false, idempotentHint=false and destructiveHint=false, so the write/non-repeatable profile is covered structurally. The description adds essentially nothing beyond that: it does not disclose that this is an asynchronous job, how results are returned, credit cost, or rate limits — all important for a batch mutation.

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 with no filler, but it is so terse that it functions closer to a title than an instruction and omits the batch-size constraint that the schema imposes.

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 an asynchronous batch submission with no output schema and a nested 1000-item array, the description should convey what is returned (e.g., a batch identifier) and how to collect results. Neither is present, leaving a significant gap an agent needs to call this 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% — the nested full_name/domain fields are documented and explicitly cross-reference the single find-email endpoint's semantics. The description adds no parameter meaning of its own, so 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?

States a specific verb (submit) and resource (bulk find-email batch), which is clearly distinguishable from the singular contacts-enrich_work_email. It does not, however, contrast itself with the sibling contacts-enrich_work_email_batch_get that presumably retrieves results, so the batch lifecycle is not made explicit.

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 prefer batching over the single find-email endpoint, how many contacts to submit, or that results must later be fetched via contacts-enrich_work_email_batch_get. The word 'bulk' implies scale but offers no threshold or 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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds only the word 'poll', giving no insight into batch lifecycle states, how to tell a batch is finished, rate limits, or why polling is safe/necessary.

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 six-word phrase with zero filler, so nothing is wasted. However, it is arguably under-specified rather than truly concise; a brief clause on what polling yields would earn its place without bloat.

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 carries the burden of explaining return semantics, yet it says nothing about status values or what a completed batch returns. For a polling endpoint this leaves a meaningful gap an agent must guess at.

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

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

Only one parameter exists and schema description coverage is 100%, with the schema itself explaining that id is 'the batch_id returned by the submit call.' The description adds nothing beyond that, so the baseline of 3 for fully documented schema 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?

States a specific verb ('poll') and resource ('bulk find-email batch'), making clear this retrieves status/results rather than initiating work. The verb implicitly distinguishes it from the submit sibling (contacts-enrich_work_email_batch), but no sibling is named explicitly and the object returned is not characterized.

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?

'Poll' implies repeated invocation until a batch completes, but the description gives no when-to-use guidance, no completion condition, and no pointer to the submit tool that generates the required id. There are no exclusions or alternatives offered.

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 declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered. The description adds only that lookup is by external ID and confirms a source name is needed; it does not disclose return format, error behavior for unknown IDs, or rate limits.

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

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

A single efficient sentence with the key detail (external system ID) front-loaded. No waste, though it could be slightly tighter.

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 two-parameter read tool with full annotation coverage, the description is adequate to invoke correctly. With no output schema, however, it says nothing about what the returned 'contact research' contains, which is a modest 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%, and both parameters already carry descriptions with the same HubSpot example given in the tool description. The description thus adds no meaning beyond the schema, 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?

States a specific verb ('Retrieve') and resource ('contact research') plus the lookup key ('external system ID'). The 'external system ID' framing functionally distinguishes it from the sibling contacts-get_research (internal ID), though it does not name that sibling explicitly.

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

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

It implicitly tells the agent to use this when an external system ID (e.g., HubSpot) is available, which is useful context. However, it never names the alternative contacts-get_research or states when NOT to use this tool, leaving the choice between the two lookup tools to inference.

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 useful behavioral context by naming the backing data source and authorization scope ('API key owner's Sales Navigator connection'), which is not present in the annotations. It does not describe side effects, credit consumption, result boundaries, or behavior on connector failure; those details live in the parameter schema rather than the tool 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 sentence with the verb and object front-loaded, followed by a compact list of filter dimensions and the key data-source constraint. There is no padding, no repetition of schema details, and every phrase contributes to selection and invocation understanding.

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

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

For a complex search tool with no output schema, the top-level description covers search scope and data source but omits what a response looks like, pagination behavior, and when to prefer a sibling contact tool. The rich input schema compensates for parameter-level detail, but the description alone is not fully self-sufficient for an agent.

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

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

Schema description coverage is 100%, and the schema's parameter descriptions are unusually detailed, covering pagination cursor semantics, mutually exclusive fields, enum constraints, OR/AND filter behavior, and normalization rules. The tool description only lists coarse filter categories and therefore adds little meaning 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 specific action ('Search for contacts'), identifies the resource clearly, and enumerates the main filter axes (person, role, tenure, industry, company headcount/type, recent job change). It stops short of a 5 because it does not explicitly name sibling tools or state what this search is not, leaving some differentiation to inference.

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: when an agent needs to find contacts by the listed attributes. It also adds a relevant prerequisite by noting the search uses the API key owner's Sales Navigator connection, but it gives no explicit guidance about alternatives, exclusions, or situations where a different contact tool 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 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 already declare readOnlyHint=false and idempotentHint=false, and the description 'Create a monitor' is consistent with a mutation. However, the description adds no behavioral detail beyond the annotations – it does not mention potential billing charges, delivery behavior, or the ability to create a monitor without a webhook. It relies entirely on the schema for such 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 fluff. It is front-loaded with the verb and object, but it is so minimal that it conveys almost no information. It is appropriately sized in that it is not verbose, though it could arguably be longer to be useful.

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 highly complex schema with nested objects and detailed field descriptions, the one-sentence description is inadequate. It provides no high-level overview of what a monitor is, how to choose between list/market targets, or what happens on creation. The schema does most of the heavy lifting, but the description does not help an agent understand the overall purpose or decision points.

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 rich descriptions for fields like webhook.url and intervalSignalLimit. The tool description adds nothing about parameters, so the baseline of 3 applies; the schema carries all 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 'Create a monitor' is essentially a tautology – it restates the tool name (monitors-create). It states a verb and resource but does not add any distinguishing context, such as what a monitor is or how it differs from monitors-create_action. It is minimally clear but adds no value beyond the 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 gives no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or contrast with sibling tools like monitors-create_action or monitors-update. An agent receives no directional help.

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.

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

The schema has 0% description coverage, and the tool description does not explain the monitorId parameter beyond its name. It does not clarify how to obtain the ID, validate it, or what it refers to beyond the obvious. The description adds minimal value over the schema.

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

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

The description clearly states the action ('delete') and the resource ('monitor'), which is specific and differentiates it from sibling tools like monitors-delete_action and monitors-pause.

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-pause or monitors-update. It does not mention prerequisites, consequences of deletion, or any context where a different tool should be preferred.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description does not need to restate that this is a write/destructive operation. However, the description adds no additional behavioral context beyond the resource scope ('a monitor action'), such as whether deletion is reversible or cascades.

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 the 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 tool is simple: 2 UUID parameters, no output schema, and annotations covering destructive/idempotent semantics. The description is sufficient for an agent to understand the primary function, though it omits details about response codes or behavior when the action doesn't exist.

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 0%, and the description doesn't clarify that monitorId is the parent resource and actionId is the sub-resource. Parameter names are self-explanatory, but the description fails to compensate for the missing schema descriptions by explaining the relationship or any required preconditions.

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 a specific verb and resource ('Delete a monitor action'), clearly distinguishing from siblings like monitors-delete (which deletes a whole monitor) and monitors-update_action. The phrasing ties directly to the tool's name and 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 on when to use this tool versus alternatives such as monitors-delete or monitors-pause_action. It does not state prerequisites (e.g., that the monitor and action must exist) or mention any related cleanup.

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=true, destructiveHint=false, and idempotentHint=true, so the safety profile is covered. The description adds no additional behavioral context, but it is consistent with the annotations.

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

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

The description is extremely short and to the point, with no unnecessary words. It front-loads the key action and resource, but its brevity sacrifices additional useful 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?

This is a simple get operation with rich annotations and a single parameter. The description is minimal but adequate for the agent to infer basic usage, though it lacks details about return values or error handling.

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 one parameter (monitorId) with no description, yielding 0% coverage. The parameter name is self-explanatory, and the description implies the need for an identifier, but it doesn't explicitly state its meaning or format 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 'Get' and names the resource 'monitor', clearly indicating a single-resource retrieval. However, it doesn't differentiate from sibling tools like monitors-list or monitors-get_action, so it only partially distinguishes.

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 context is provided for when to use this tool versus other monitor-related tools. There are no examples, prerequisites, or alternatives 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 declare readOnlyHint, idempotentHint, and destructiveHint=false, so the description adds no additional behavioral context. It does not mention the relationship between monitorId and actionId, potential error cases, or any other behavioral details beyond what annotations provide.

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

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

The description is one short sentence, but it is under-specified and essentially restates the tool name. It is not appropriately concise; it lacks substance and provides minimal value beyond the 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?

Given the low complexity and comprehensive annotations, the description still leaves important gaps: it does not clarify what a monitor action is, how monitorId and actionId relate, or how this retrieval differs from listing actions. Sibling tool names help indirectly, but the description alone is incomplete.

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 compensate. It does not explain the roles of monitorId and actionId, only relying on the parameter names. The agent receives no semantic explanation beyond the UUID patterns in the schema.

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

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

The description clearly states the tool retrieves a monitor action using a specific verb and resource. It is not vague and can be easily understood, though it does not explicitly differentiate from sibling tools like monitors-list_actions or monitors-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?

No guidance is provided on when to use this tool versus alternatives such as monitors-list_actions or monitors-get. There is no mention of prerequisites or typical 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds no behavioral context beyond that. It does not mention rate limits, authentication, or return characteristics, so it provides no 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?

Although the description is short, it is severely under-specified rather than appropriately concise. It provides no useful structure or information beyond the tool name, so it fails to serve the user effectively.

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

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

For a tool with 4 optional parameters, no output schema, and no parameter descriptions, the one-line description is woefully incomplete. It doesn't explain what monitors are, what fields are returned, or how filtering and pagination work, leaving the agent without essential context.

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

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

With schema description coverage at 0%, the description needed to explain parameters, but it entirely omits them. The schema's enums and defaults are present, yet the description adds no semantic meaning to kind, target, limit, or offset.

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 monitors' is a direct restatement of the tool name 'monitors-list', making it a tautology. It provides no additional scope or context to clarify what monitors are or how this list differs from sibling list operations.

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

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

The description offers no guidance on when to use this tool versus alternatives like monitors-list_actions or monitors-list_signals. It also fails to mention the optional filtering parameters (kind, target) or pagination controls, leaving the agent without decision-making support.

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

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

Annotations declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true; the description aligns with these but adds no additional behavioral context such as pagination, ordering, or response format. The annotations already cover the safety profile, so a neutral 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 sentence, 'List monitor actions', with no redundant words or filler. It is perfectly front-loaded and appropriately sized for the tool's simplicity.

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 list operation, the description is adequate but omits context about what 'actions' are, whether the list is scoped to the given monitorId, and what the return value contains. However, the tool's purpose is clear enough when combined with the parameter name and sibling tools.

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 requires a monitorId (UUID format), but the description does not explain that this parameter scopes the action list. With 0% schema description coverage, the description should compensate for the parameter's meaning but does not, leaving the agent to infer from the parameter name 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 monitor actions' uses a specific verb and resource, clearly distinguishing it from sibling tools like monitors-list (list monitors) and monitors-get_action (retrieve a single action). It is unambiguous and concise.

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 specify when to choose this over monitors-list_signals or monitors-get_action, nor does it mention the requirement for a monitorId or any filters.

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 openWorldHint, so the safety profile is covered. However, the description adds no behavioral context such as pagination behavior, ordering, side effects, or what constitutes a 'signal'. It offers no 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?

The description is a single, front-loaded sentence with no wasted words. It is concise, though it sacrifices informativeness in other dimensions.

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 vastly underspecified. With no output schema, no parameter details, and no elaboration on what signals are returned or how pagination works, an agent would struggle to use this tool correctly. The minimalism leaves too many 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 0% and the description provides no explanation of the parameters (monitorId, limit, offset). The agent must rely solely on parameter names, which is insufficient for correct invocation.

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

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

The description clearly identifies the action (List) and the resource (a monitor's signals). However, it does not distinguish itself from sibling tool names like contacts-list_signals or market_signals-list_signals beyond the resource 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?

No guidance is provided on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description is a bare statement of functionality.

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 convey that this is a mutating, non-idempotent operation (readOnlyHint=false, idempotentHint=false, destructiveHint=false). The description 'Pause a monitor' aligns with these annotations and adds no contradiction, but it also provides no additional behavioral context, such as whether pausing stops generation of new signals or if it is reversible. It is consistent and minimally informative.

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 at three words, with no filler or redundancy. It is appropriately sized for a simple operation and front-loads the core action. However, it sacrifices useful context, which is penalized in other dimensions.

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 pause operation with one ID parameter and no output schema, the description is minimally adequate. It states the action and resource, but omits domain context such as the effect on the monitor's status, whether it can be resumed, and any relation to sibling tools like 'monitors-resume'. It is sufficient to perform the action with the given schema, but lacks completeness for an agent unfamiliar with the domain.

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

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

The description does not mention the monitorId parameter at all, and with schema description coverage at 0%, there is no compensation from the description. Although the parameter name 'monitorId' is self-explanatory and the schema gives its UUID format, the description adds no semantic value beyond the schema, leaving a notable gap.

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 action verb 'pause' with the clear resource 'monitor', making its primary purpose evident. However, it does not explicitly distinguish between pausing a monitor and the sibling tool 'monitors-pause_action', which pauses a monitor's action. The name 'monitors-pause' helps, but the description alone is unambiguous only to a domain-aware reader.

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 about when to use this tool versus alternatives like 'monitors-pause_action' or 'monitors-resume'. There is no mention of prerequisites, effects, or when pausing a monitor is appropriate. The description carries no 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?

Annotations already indicate this is not read-only, not idempotent, and not destructive, but the description adds no additional behavioral context. It does not explain what pausing an action involves, whether it is reversible, or any 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, clear sentence that front-loads the action. It is appropriately sized for a simple operation, though it could include a bit more context without becoming verbose.

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

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

For a tool with only two parameters and no output schema, the minimal description might seem sufficient, but it lacks critical context. It does not explain the relationship between monitor actions and monitors, what pausing an action does to signal generation, or whether the operation is reversible. This makes it incomplete for an agent to correctly reason about the tool's 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?

Schema describes both parameters only by name and format, with no descriptions. The tool description does not clarify what monitorId and actionId refer to beyond the obvious, nor what constitutes an 'action' in this context. With 0% schema coverage, the description should compensate but does not.

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 'Pause a monitor action' clearly identifies the specific action (pause) and the resource (monitor action). It distinguishes from siblings like monitors-pause (which would pause the whole monitor) and monitors-resume_action (the opposite operation).

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, typical scenarios, or warnings about when not to use it, which is especially problematic given the sibling tools like monitors-pause and monitors-resume_action.

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, destructiveHint=false, and idempotentHint=false, but the description adds no behavioral context. It does not explain side effects, prerequisites, or whether the monitor must be paused. The description merely restates the tool's name without enriching the annotations.

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

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

The description is extremely concise (one short sentence), which is efficient for a simple tool, but it is under-specified rather than appropriately concise. It lacks any supporting details that could be included without bloating, so the brevity is not a strength in this case.

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 technically complete in naming the action, but it fails to provide necessary context. It does not clarify what 'resume' means (e.g., reactivating a paused monitor), nor does it address the relationship to sibling tools like monitors-pause or monitors-resume_action. An agent may not know when to invoke this over alternatives.

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 defines monitorId as a UUID, but the description provides no additional meaning about it. With schema description coverage at 0%, the description was expected to compensate, but it does not mention the parameter at all, leaving the agent to infer its purpose solely from the schema.

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

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

The description 'Resume a monitor' clearly identifies the action (resume) and the resource (monitor), effectively distinguishing it from siblings like monitors-resume_action, which resumes a specific action. It is a specific verb+resource pairing, though it could be slightly clearer about what resuming 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 guidance on when to use this tool versus alternatives. It does not mention that it should be used only for paused monitors, nor does it reference related tools like monitors-pause or monitors-resume_action. There is no context for decision-making.

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, non-destructive operation. The description adds no additional behavioral context, such as potential side effects, required permissions, or what happens if the action is already resumed. With annotations covering the basic profile, useful context is still missing.

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 brief, which is concise but borders on under-specification. It is a single phrase that essentially restates the tool name. While it is front-loaded and easy to parse, it does not offer much value beyond the name itself.

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

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

Given that this is a mutation operation with two parameters, no output schema, and sparse annotations, the description is inadequate. It does not explain what a monitor action is, the effect of resuming, or any preconditions. The lack of depth would force an agent to rely on the schema and sibling tools for context.

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

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

Schema description coverage is 0%, and the description does not elaborate on the meaning or relationship of monitorId and actionId. The parameter names are self-explanatory to some extent, but the description fails to compensate for the lack of schema descriptions, leaving the agent to guess their roles beyond their labels.

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 'Resume' and resource 'monitor action', which distinguishes it from similar siblings like 'monitors-resume' (which would act on a monitor, not an action). However, it lacks any additional details that would further disambiguate it from related actions like 'monitors-pause_action' or 'monitors-update_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?

There is no guidance on when to use this tool, prerequisites, or alternatives. It does not explicitly say 'use after pausing an action' or mention any required state. The single phrase provides only implicit context, leaving the agent to infer usage from the name and sibling tools.

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

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

The description adds no behavioral context beyond the word 'trigger'. Annotations indicate the tool is mutating (readOnlyHint=false) and not destructive, but the description does not disclose whether the run is asynchronous, whether a run ID is returned, or any 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 is direct and free of verbose language. It is appropriately sized for a simple trigger action, 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?

The description is too minimal for a trigger action. It does not explain what happens after triggering (e.g., asynchronous execution, return value, or whether a monitor must be active). With no output schema, the description should provide more operational context to be 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 0%, and the description provides no additional meaning for the monitorId parameter. The schema only gives type and format, leaving the agent without semantic guidance on what the parameter does or represents.

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 verb 'Trigger' is specific and the resource 'monitor run' is clear. It distinguishes from siblings like monitors-pause, monitors-resume, and monitors-update by focusing on executing a run rather than altering the monitor's state or configuration.

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. There is no mention of prerequisites, context, or exclusions. The description only states the action without any contextual 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?

The description adds no behavioral context beyond what the annotations already convey. Annotations state readOnlyHint=false (mutation) and destructiveHint=false, and 'Update' is consistent with that, but nothing is disclosed about idempotency, partial vs. full replacement, permission requirements, or side effects on downstream signals. With annotations present, the description could add value but does not.

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 generic sentence, which is under-specification rather than conciseness for a tool with deeply nested parameters and multiple conditional fields. It front-loads nothing useful and fails to earn its place by conveying any actionable information.

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

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

Given the complexity of the input schema (nested objects, multiple enums, conditional fields) and the absence of an output schema, the one-line description is grossly insufficient. An agent cannot determine what fields are updatable, how the request body interacts with existing monitor settings, or what the response looks like. This is completely inadequate 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 description contains zero parameter information. With schema description coverage at 50%, the schema partially documents nested fields, but the description does nothing to compensate for the undocumented half or clarify parameter behavior. An agent gets no help from the description in understanding monitorId or __requestBody beyond their raw schema.

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

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

The description states a specific verb (Update) and resource (a monitor), and the tool name mirrors this, distinguishing it from sibling operations like monitors-create, monitors-delete, and monitors-pause. However, it does not describe what aspects of a monitor can be updated (e.g., name, checks, webhook, schedule), so it is clear but not fully differentiated from other update tools like monitors-update_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?

No usage guidance is provided. The description does not say when to use this tool versus alternatives, when not to use it, or any prerequisites. An agent must infer usage solely from the name and schema.

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 the annotations already state. It does not disclose whether the update is partial or full replacement, what side effects occur, or any requirement for the action to already exist. Annotations provide readOnlyHint=false and destructiveHint=false, but the description adds nothing extra.

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 brief, but it is under-specification rather than concise. It is a single sentence that merely restates the tool's name without added value, so it is not appropriately sized for a tool with a complex nested request body.

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

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

Given the tool has 3 required parameters, a nested request body, and no output schema, the description is inadequate. It provides no information about return values, update semantics, or required fields, making it incomplete for an agent to correctly invoke the tool.

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

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

The description makes no reference to the parameters (monitorId, actionId, __requestBody). Schema description coverage is only 33%, leaving the nested webhook configuration largely unexplained. The description does not compensate, offering zero semantic help for understanding the request body.

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 a monitor action' states a clear verb and resource, but it does not specify what an 'action' is or what 'update' entails. It is very close to a paraphrased tool name and fails to distinguish from sibling tools like monitors-pause_action or monitors-resume_action, which also modify action state.

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 monitors-create_action, monitors-pause_action, or monitors-delete_action. There is no mention of prerequisites, 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?

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 what data is returned or authentication requirements, but it does not contradict the annotations.

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

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

The description is a single concise sentence, front-loaded with the action and resource, with no unnecessary words 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?

The tool has no output schema, so the description should provide some indication of what the profile contains or what the response looks like. It does not mention return values or fields, leaving the agent to infer. However, given the simplicity and annotations, it is minimally 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?

There are zero parameters, so there is nothing to explain. The schema coverage is trivially 100%, and the baseline for zero params is 4; the description does not need to add parameter details.

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 verb 'Get' and resource 'your organisation profile' clearly specify the action and target. It distinguishes from the sibling 'organisation-update' and other getters by referencing the organisation profile specifically.

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 no guidance on when to use this tool vs alternatives, such as 'organisation-update' or other profile-related tools. There is no mention of prerequisites or context in which it 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 context beyond annotations already provided (readOnly=false, idempotent=true, destructive=false). It does not explain whether the update is partial or full, nor any side effects or permission requirements.

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 redundant content. It is front-loaded with the purpose, earning 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 nested request body and no output schema, the description is too sparse. It does not clarify that only specified fields are updated, nor that sub-fields are optional, which is important for correct 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 provides descriptions for all properties (100% coverage), so the baseline is 3. The description adds no parameter-level meaning, but this is acceptable given the schema's completeness.

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 'update' and resource 'organisation profile', clearly indicating a write operation. It distinguishes from sibling tool 'organisation-get' by implying modification rather than 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 description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. It does not mention other organisational tools or clarify update semantics.

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

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

Annotations already establish that this is a write operation (readOnlyHint=false) that is not idempotent and not destructive. The description adds the bulk aspect and the 'profile' target but does not disclose any side effects, partial-failure behavior, or rate limits, leaving the behavioral profile thin.

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 redundant words. It conveys the core purpose in a compact form.

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 write tool with no output schema, the description is adequate but not comprehensive. The schema and annotations supply the required structure and safety flags, but the description does not mention error handling, return values, or edge cases, leaving some questions for a complex operation.

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

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

The input schema covers the single __requestBody parameter with a description, so the schema provides full coverage. The description adds no additional parameter semantics beyond naming the action, and nested field meanings (profileId, objectType) are left to the schema, which is adequate per baseline.

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

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

The description clearly states the action (assign) and resource (profile) with a bulk scope ('many objects at once'), which distinguishes it from the single-assignment sibling tools. It could be more explicit about the scoring context or name alternatives, but the core purpose is 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 the tool is for bulk assignment scenarios but does not explicitly state when to use it over scoring-assignment-create or mention any exclusions or prerequisites. The usage context is implied by the bulk phrasing rather than directly guided.

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=false and destructiveHint=false, so the description does not need to restate safety. However, it adds no behavioral context beyond the basic 'assign' action, such as whether existing assignments are overwritten, whether it errors on duplicates, or what side effects occur. No extra transparency is provided.

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

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

The description is a single, front-loaded sentence containing zero filler. Every word contributes meaning, 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 low-complexity with a clear schema and annotations, but there is no output schema and the description does not mention return values or behavioral edge cases like idempotency or overwrite semantics. It is adequate for basic selection but leaves gaps for an agent expecting robust guidance.

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

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

The schema description coverage is 100%, so the input schema already documents parameters like objectId, profileId, and objectType. The description adds no parameter-level detail, but with full schema coverage 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 clearly states the action ('Assign'), the resource ('a profile'), and the target ('a single object'), which precisely matches the tool's function. The qualifier 'single' distinguishes it from the sibling tool scoring-assignment-bulk-create, providing clear 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 gives clear context for when to use this tool: assigning a profile to a single object. It implicitly sets it apart from the bulk-create sibling, though it does not explicitly name alternatives or when not to use it. This is clear context without exclusions.

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