Business Days & SLA

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

Core behavior disclosed (skips weekends/holidays, negative support). No annotation provided, so description carries full burden. Missing details: handling of non-business-day input dates, reliance on country/subdivision for holidays, return format.

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

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

Three sentences, no wasted words, front-loaded with primary purpose. Each sentence adds essential information.

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

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

Given no output schema and 4 parameters, description covers the core function but omits return format, non-business-day starting date behavior, and optional parameter semantics. Adequate but with 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?

Adds meaning for 'date' and 'days' (negative/zero), but does not explain 'country' and 'subdivision' parameters. Schema coverage is 50%, so description should compensate but fails to do so for the optional parameters.

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

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

The description clearly states the action ('Move'), resource ('number of working days from a date'), and key details (skipping weekends/holidays, negative/zero behavior). It is distinct from sibling tools like next_business_day or business_days_between.

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 clear context: use to offset a date by business days, with explicit mention of negative values for backwards. Lacks explicit when-not-to-use or alternatives, but the negative number guidance is helpful.

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

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

With no annotations, the description carries full burden. It discloses half-open range, negative results, and excludes weekends and public holidays, but fails to mention that country/subdivision parameters determine which public holidays are excluded, leaving a transparency gap.

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

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

Two sentences, front-loaded with purpose, then behavioral detail. No wasted words.

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

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

The description adequately explains the core counting logic and result sign, but lacks explanation of how country/subdivision affect the count. With 4 parameters and no output schema, this omission reduces completeness.

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

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

Schema coverage is 50% (only start_date and end_date have descriptions). The description adds meaning for those two parameters (start counts, end does not) but provides no explanation for country and subdivision parameters, which are critical for accurate holiday exclusion. The description does not 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 the tool counts working days between two dates, excluding weekends and public holidays. This verb+resource phrasing distinguishes it from siblings like is_business_day, next_business_day, and add_business_days.

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

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

The description explains the half-open range behavior and negative result for reversed dates, providing clear usage context. However, it does not explicitly state when to use this tool versus alternatives like add_business_days.

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

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

Discloses invoice is draft, needs approval, and authorization requirement. No annotations exist, so description carries burden. Lacks detail on error handling or parameter validation, and inconsistency with 'line items' reduces transparency.

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

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

Three sentences with key information front-loaded. No wasted words. Very concise and well-structured.

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

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

Given no output schema and minimal param descriptions, the description is incomplete. Lacks details on return value, error behavior, and does not compensate for the schema's lack of param descriptions. The line items vs amount discrepancy also harms completeness.

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

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

Schema has no descriptions (0% coverage). Description says 'customer identifier' for customer_id, which is basic. Mentions 'line items' but schema only has a single 'amount' – this misalignment confuses parameter meaning. Amount is not explained.

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

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

Clearly states 'Create a draft invoice' – specific verb and resource. Distinguishes from sibling tools as no other invoice creation tool exists. However, mentions 'line items' which conflicts with schema's single 'amount' parameter, slightly reducing clarity.

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 context: draft state requires human approval, and Business-tier authorization is needed. Does not explicitly state when not to use or list alternatives, but no direct siblings exist.

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

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

No annotations provided, so description carries full burden. Discloses key behavioral trait: non-execution. However, does not mention whether it validates or returns errors for invalid expressions, which is a minor gap.

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

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

Two concise sentences, no filler. First sentence states purpose, second adds behavioral constraint. Well front-loaded.

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

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

Simple tool with one parameter and no output schema. Description covers purpose and side-effect safety. Could mention return format (plain English string), but not essential for agent to use correctly.

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

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

Only one parameter with 100% schema coverage. Description adds no additional meaning beyond the schema's example. The example is helpful but not extra semantic value, so baseline 3.

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

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

Description states verb 'Translate' and resource 'five-field cron expression into plain English'. Clearly distinguishes from siblings like 'validate_cron_expression' and 'next_cron_occurrences' by specifying a different action (translation vs validation/calculation).

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?

Includes explicit statement 'it never schedules or executes anything', guiding against misuse for execution. Could be improved by contrasting with sibling 'validate_cron_expression' but still clearly indicates read-only intent.

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

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

With no annotations, the description carries the full burden and clearly states that nothing is scheduled or executed, indicating no side effects. This adds transparency about the tool's non-destructive behavior.

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

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

The description is composed of two concise sentences with no wasted words. The core purpose is front-loaded, and every sentence adds value.

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

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

Given the tool's simplicity (single string input, plain English output) and the presence of siblings for validation and occurrences, the description is adequate. It does not cover error handling for invalid rules, but 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?

Schema coverage is 100%, and the description does not add meaning beyond the schema's parameter description ('An RFC 5545 recurrence rule'). Thus, baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'describes' and the resource 'iCalendar recurrence rule', and specifies 'in plain English'. It also distinguishes from execution by noting 'Nothing is scheduled or executed', which sets it apart from siblings like 'next_recurrence_occurrences'.

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 safe, read-only usage and contrasts with execution-oriented tools. However, it does not explicitly mention when to use this over siblings like 'validate_recurrence_rule' or 'next_recurrence_occurrences', though the context provides enough 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?

With no annotations, the description carries full burden. It discloses that it searches workspace history and requires authorization, but lacks details on side effects, rate limits, result count, or error behavior. The mention of 'semantically similar' provides some transparency, but more is needed.

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

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

The description is concise with two sentences, front-loading the action and purpose. Every sentence adds value without redundancy.

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

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

Given the tool's simplicity (1 parameter, no output schema, no annotations), the description covers the core functionality, purpose, and authorization. It does not detail output structure, but the absence of an output schema reduces the need. Minor gaps like result limits are acceptable.

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

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

The single parameter 'ticket_text' has no schema description (0% coverage). The description implies it's the text of a support ticket but does not specify format, length limits, or handling of empty input. Minimal added 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 uses specific verb 'returns' and resource 'previously resolved tickets', clearly stating the tool's function. It also explains the purpose ('reuse resolution') and distinguishes from siblings like 'search_internal_docs' by focusing on support tickets.

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 indicates when to use (given ticket text, reuse resolution) and includes an authorization prerequisite (Business-tier). However, it does not provide explicit when-not-to-use or mention alternatives among siblings, though the context implies distinction.

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

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

Discloses read-only nature and no side effects. Mentions default country and that subdivision narrows holidays. No contradictions with annotations (none provided). Could be slightly more detailed about return format, but sufficient.

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 efficient sentences: main action, usage guidelines, alternative tools, and default/region info. No wasted words.

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

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

Given no output schema, description could specify return type (e.g., date string or object). However, the scanning logic is clear, and the result is implied to be a date. Slight gap but not critical.

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

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

All 4 parameters have schema descriptions (100% coverage). Description adds context: year and month are obvious, but it clarifies country default (US), subdivision purpose, and regional differences.

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 'Returns' and the resource 'first working day of a calendar month', with scanning logic explained. It distinguishes from siblings like last_business_day_of_month and next_business_day.

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

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

Explicitly states when to use (month-opening deadlines) and when not to (use last_business_day_of_month for closing end, next_business_day for arbitrary dates). Provides clear alternatives.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states that it gets the balance and requires authorization. It does not mention idempotency, error behavior (e.g., what happens if account not found), or whether it is a read-only operation beyond the implication of 'get'.

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 action and resource. It is concise, but could benefit from a brief explanation of the parameter and return value 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?

The tool is simple with one parameter and no output schema. The description covers the basic purpose and a prerequisite (authorization), but lacks details about the parameter and behavioral traits, making it barely adequate for a tool of this complexity.

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

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

Schema coverage is 0%, meaning the parameter 'account_id' has no description in the schema. The tool description does not elaborate on the format, source, or expected values of the account_id, leaving the agent to guess. This is insufficient for a single required parameter.

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

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

The description clearly states the verb (Get) and resource (balance of a billing account), and specifies the workspace scope. It does not explicitly differentiate from siblings, but no sibling tool has an overlapping purpose.

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

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

The description mentions the Business-tier authorization requirement, which is useful context for when the tool can be used. However, it does not provide guidance on when to use this tool versus alternatives, nor does it specify 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?

No annotations provided, so description carries full burden. It discloses read operation, included fields, database source, and authorization requirement (Business-tier). Does not mention error handling or rate limits, but sufficient given tool simplicity.

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

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

Two sentences, no redundancy, front-loaded with core function. Every sentence adds value: first covers purpose, second covers usage and constraints.

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

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

Tool has one parameter, no output schema. Description covers purpose, usage, and auth requirement. Lists returned fields partially. Lacks error scenario details, but complexity is low.

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

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

Schema coverage is 100%, so baseline is 3. Description adds context for output but not for the parameter itself; 'unique identifier' is clear but no format guidance. Schema description already suffices.

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 full customer record, specifying verb, resource, and included fields (account status, plan tier, primary contact). It sufficiently distinguishes from sibling tools like lookup_order_status.

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

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

Explicitly says 'Use this when you need authoritative details about a specific customer', providing clear context. Lacks explicit when-not-to-use or alternatives, but no direct alternatives exist among siblings.

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

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

No annotations are provided, so the description carries full burden. It only states it returns config and requires auth, omitting behavioral traits like side effects, rate limits, or what exactly the config contains. For a read operation, minimal transparency but lacking 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?

Single, front-loaded sentence with no redundant words. Every part is necessary: action, resource, scope, and authorization requirement.

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 (one parameter, no output schema, no annotations), the description is adequate but not complete. It lacks details about the parameter and the return value, though the core purpose is clear.

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

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

Schema description coverage is 0%, so the description must compensate. It does not add any meaning beyond the schema: 'deployment' is unexplained. The description fails to clarify what format or value is expected.

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 ('Returns') and the resource ('environment configuration') with a scope ('for a deployment in the connected workspace'). It is specific and distinguishes from siblings, none of which are similar.

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 mentions a prerequisite (Business-tier authorization) but provides no guidance on when to use this tool vs alternatives or when not to use it. Usage is implied but not explicit.

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

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

With no annotations, the description carries full burden. It discloses that the tool checks against weekends and public holidays (a query behavior). It does not cover side effects, which are absent, but could mention it's a read-only operation. Still, it's adequate for a simple boolean check.

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 of 17 words, front-loaded with the core purpose, and every word is essential. No wasted words.

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

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

For a simple tool with 3 parameters and no output schema, the description explains the return type implicitly ('Returns whether'), the logic (weekends and holidays), and geographic scope. It could explicitly state the return type (boolean) but is largely complete.

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

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

Schema coverage is 100%, and the description adds meaning by specifying that country and subdivision parameters affect which holidays are considered, and mentions the default for country. This goes beyond the schema's type/format 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 uses a specific verb 'Returns whether' with the resource 'a date is a working day', clearly distinguishing it from siblings like `add_business_days` or `next_business_day` by focusing on a single date check.

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 states the tool accounts for weekends and public holidays, providing context, but does not explicitly guide when to use this over similar siblings like `next_business_day` or `previous_business_day`. No exclusions or alternatives 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?

No annotations provided; description fills gap with 'Read-only; nothing is scheduled' (non-destructive). Also explains scanning backwards past weekends/holidays. Could add more about default country behavior, but country parameter descriptions cover that.

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, each earning its place: purpose, read-only clarification, usage guidelines, parameter nuance. Front-loaded with core action. No redundancy.

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

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

No output schema, but description explains return value (last working day). Covers parameters, behavior, and usage context thoroughly. No missing aspects given tool simplicity.

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

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

Schema coverage is 100%, so description adds value beyond schema: defaults to US, subdivision narrows holiday set (e.g., SCT for Scotland). This enhances meaning of optional 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?

Description clearly states 'Returns the last working day of a calendar month' – specific verb and resource. Explicitly distinguishes from siblings like first_business_day_of_month and previous_business_day.

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

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

Provides explicit when-to-use scenarios: 'month-end deadlines such as payroll, invoicing or period close'. Also specifies when not to use: use first_business_day_of_month for opening, previous_business_day for arbitrary dates.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It only adds the authorization requirement but fails to mention error handling, rate limits, or response format. For a tool that lists sensitive keys, more transparency is needed.

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, concise, but it sacrifices important details. It could include parameter guidance or output hints without becoming too long.

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

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

Given no output schema and no annotations, the description is incomplete. It does not explain the output structure, error scenarios, or provide sufficient context for an agent to use the tool correctly.

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

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

Schema coverage is 0% (no description for 'service'). The description does not clarify what values 'service' accepts (e.g., names, IDs, formats). No additional meaning beyond the bare parameter name.

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

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

The description clearly states the action ('List') and the resource ('API keys for a service in your workspace'). It also mentions a key constraint (Business-tier authorization), which helps distinguish it from other list tools like list_directory.

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 one usage condition (requires Business-tier authorization) but does not explain when not to use it or mention alternatives among similar sibling tools like rotate_service_token.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only discloses the authorization requirement but omits other behaviors such as read-only nature, recursion depth, performance implications, or error handling.

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 very concise with two short sentences, no redundancy. However, it might benefit from slightly more detail, such as the nature of the returned entries.

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 simplicity of the tool (one parameter, no output schema, no annotations), the description should provide a complete picture. It lacks details about return format, recursion, file filtering, and error scenarios, making it insufficient for full understanding.

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

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

The input schema has 0% description coverage, and the tool description adds no information about the 'path' parameter. It does not specify format (relative/absolute), allowed characters, or default behavior. The description fails to compensate for the schema 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 clearly states the action ('Lists the entries') and the resource ('a directory of the workspace's file storage'). It distinguishes from siblings like read_file by focusing on listing, not reading. However, it does not specify what information is returned (e.g., names only, types, sizes).

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 mentions the authorization requirement ('Requires Business-tier authorization'), which provides some usage context. However, it gives no guidance on when to use this tool versus alternatives like read_file, nor does it 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It correctly indicates a read operation and notes authorization requirements, but it fails to disclose important behavioral traits such as pagination, result limits, or what 'recent' means. This leaves the agent uncertain about call behavior.

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

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

The description is extremely concise, consisting of only two sentences that are front-loaded with the core action. Every sentence adds value: the first defines what the tool does, and the second adds a critical authorization prerequisite. There is no wasted text.

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 (single parameter, simple list operation) and the absence of an output schema and annotations, the description covers the essential purpose and a key prerequisite. However, it omits details about return structure, pagination, and the interpretation of 'recent', which are moderately important for an agent to invoke the tool correctly.

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

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

The input schema has 0% description coverage for the account_id parameter, so the description must add meaning. The description implies account_id identifies the account, but provides no further details such as the expected format, source, or constraints. This is minimal compensation for the schema's lack of documentation.

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 ('Lists recent transactions') and the target resource ('for an account in the connected workspace'). It effectively distinguishes this tool from sibling tools such as get_account_balance (which returns a single balance) and list_api_keys (which lists API keys), making its purpose unambiguous.

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

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

The description provides some context by mentioning the required authorization level ('Requires Business-tier authorization'), which is a useful prerequisite. However, it does not explicitly state when to use this tool over alternatives, nor does it provide guidance on when not to use it or what the limitations are (e.g., only recent transactions).

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

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

No annotations provided. The description only adds an authorization requirement, but lacks details on read-only nature, error handling, or what happens if the order is not found.

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

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

Single sentence with no filler, front-loads the action and key requirement, making it efficient and scannable.

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?

Adequate for a simple lookup with one parameter, but lacks description of return format, error behavior, or formatting guidance for 'order_id'.

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 0% schema description coverage, the description adds no meaning beyond the schema field name 'order_id'. It does not specify expected format, example values, or 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?

Clearly specifies the action ('look up'), resource ('order status'), and scope ('in your workspace'), distinguishing it from sibling tools like 'get_customer_record' or 'list_transactions'.

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?

Mentions a key prerequisite ('requires Business-tier authorization') but does not explicitly state when to use or avoid this tool relative to 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?

The description states the tool is read-only and idempotent, and clarifies that it never returns the given date even if it is a working day. With no annotations provided, the description fully discloses behavioral 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 four sentences, front-loaded with the main purpose, and every sentence adds necessary information without redundancy. It is concise and well-structured.

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

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

Given the tool's simplicity and the presence of a clear input schema, the description covers all aspects: behavior, usage guidelines, parameter details, and differentiation from siblings. No output schema is needed for this straightforward return value.

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 adds meaning beyond the schema by specifying the default for country (US) and the purpose of subdivision (narrowing holidays, e.g., SCT for Scotland). Schema coverage is 100%, but this contextual info is valuable.

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

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

The description clearly states the tool returns the first working day strictly after a given date, stepping over weekends and holidays. It distinguishes from siblings like is_business_day and add_business_days, making the purpose unambiguous.

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

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

The description explicitly explains when to use this tool (to find next working day after a date) and contrasts it with alternatives (is_business_day, add_business_days, previous_business_day). It also notes country defaults and subdivision usage.

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?

Clearly communicates that it is a pure calculation with no side effects, which is important given no annotations. However, does not specify error behavior or any 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?

Two sentences, front-loaded with action and purpose. Every word adds value; no redundancy.

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

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

Covers core behavior and non-destructive nature. Missing explicit return format and contrast with similar siblings, but given moderate complexity it is nearly complete.

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

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

Schema covers all three parameters fully (100% coverage). Description reinforces their meaning but does not add significant new detail 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?

Describes the tool as computing future times for a five-field cron expression, using specific verb 'computes' and resource 'five-field cron expression'. Explicitly distinguishes from scheduling or creation tools by stating 'no job is created, stored, or executed'.

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

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

Implies usage for prediction without side effects, but does not explicitly state when to use vs alternatives like 'explain_cron_expression' or 'validate_cron_expression'.

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

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

With no annotations, the description carries full burden. It explicitly states the tool creates no schedule, stores nothing, and runs nothing, which clearly indicates safety and lack of side effects. It also lists the RRULE parts it honours, but does not mention error handling or output behavior, leaving minor gaps.

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

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

The description is concise, using two sentences with no superfluous words. The first sentence immediately communicates the core purpose with a specific verb and resource, and the second efficiently clarifies the tool's side-effect-free nature. Information is front-loaded.

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

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

The description is reasonably complete for a simple calculation tool, but it does not describe the output format (e.g., list of ISO date strings) or mention timezone handling. Given no output schema, a brief note about the return format would improve completeness. However, the core behavior is well covered.

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 adds value by clarifying that the rule parameter is an iCalendar RRULE and specifying which RRULE parts are supported. Since the input schema already describes all parameters (100% coverage), the description provides additional context beyond the schema without repeating details like the count range.

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 expands an iCalendar recurrence rule into its next occurrences from a start date, listing specific RRULE components it handles. It distinguishes itself from sibling tools like 'explain_recurrence_rule' and 'validate_recurrence_rule' by focusing on computation rather than explanation or validation.

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 useful context by stating it is a pure calculation with no side effects, which helps an agent decide when to use it. However, it does not explicitly name alternative tools or specify when not to use it, missing an opportunity for clearer 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?

With no annotations provided, the description carries the full burden. It discloses that the action is a publication (write) with side effects (notifying teams) and notes authorization requirements. However, it does not detail whether the tool overwrites existing statuses, rate limits, or other behavioral aspects like idempotency.

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

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

The description is concise with two sentences, each serving a clear purpose: defining the core action and stating the authorization prerequisite. No extraneous information is present.

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 0% schema coverage and no output schema, the description lacks details on parameter constraints (e.g., valid states), the role of 'note', and the expected return value or result of the operation. This leaves significant gaps for an AI 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 schema has 0% description coverage, so the description must compensate. It adds meaning to 'service' and 'state' by linking them to operational state changes, but 'note' is not mentioned. This provides partial clarity but is not fully comprehensive.

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 publishes a status update to the Vessark workspace's internal status page, with a specific purpose of notifying subscribed teams about operational state changes. This distinguishes it from unrelated siblings like 'send_email' or 'lookup_order_status'.

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

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

The description explicitly mentions that Business-tier authorization is required, providing a clear context for usage. However, it does not specify when not to use the tool or suggest alternatives, though no direct sibling exists for this function.

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

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

No annotations provided, but description discloses read-only and idempotent nature, stepping over weekends and public holidays, and that the given date is never returned. Covers country/subdivision logic. Missing error conditions or edge cases, but good for a straightforward tool.

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?

Multiple well-structured sentences. Front-loaded with main action. Concise but packs useful information. Slightly dense could be improved with bullet points, but still effective.

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

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

No output schema. Description does not specify return format (presumably a date string). Does not cover error cases like invalid date or missing holiday data. For a simple tool it's adequate but not fully complete.

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

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

Schema coverage is 100% with descriptions. Description adds default for country (US) and example for subdivision (SCT). Adds context beyond schema, justifying above baseline 3.

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

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

Clearly states it returns the last working day before a given date, stepping over weekends and holidays. Verb 'returns' and resource 'working day' are specific. Distinguishes from siblings like is_business_day, add_business_days, next_business_day.

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

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

Explicitly states when to use this tool vs alternatives: use is_business_day to test a date, add_business_days with negative count for multiple days back, next_business_day for forward step. Provides clear context and exclusions.

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

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

No annotations are provided, so the description carries the full burden. It correctly implies read-only behavior ('query', 'inspect') and discloses the requirement for Business-tier authorization. It does not mention rate limits or idempotency, but these are not critical for a read tool.

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

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

Three concise sentences, front-loaded with the primary action, and no unnecessary words.

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

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

Given the tool has only two parameters and no output schema, the description explains the purpose, inputs, and output sufficiently. It also notes authorization requirements. Missing details like output format or pagination are not critical for this simple query 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 names both parameters ('metric name and a time window') but does not add much detail beyond the schema. The schema for 'window' has a description giving an example, but the description implies both are required while schema shows only 'metric' is required. This minor ambiguity lowers the score.

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

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

The description clearly states it queries the time-series metrics store with a metric name and time window, returning aggregated series. This differentiates it from sibling tools, none of which deal with time-series metrics.

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

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

It explicitly advises using the tool to inspect operational trends before taking action, providing clear context. However, it does not specify when not to use it or mention alternatives, though none are obvious from siblings.

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

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

No annotations provided; the description only implies a read operation without disclosing behavioral details like error handling, file size limits, or return format. Insufficient for understanding side effects or constraints.

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

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

Single sentence, no redundant information. However, a slightly more structured format (e.g., noting output or requirements) could improve clarity without adding length.

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

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

Given one parameter and no output schema or annotations, the description fails to cover return values, error cases, or operational details. Incomplete for an AI agent to safely invoke.

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 'path' parameter has no description in the schema (0% coverage) and the tool description does not explain what the path should be (e.g., relative vs absolute, allowed characters). No added meaning beyond the schema.

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

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

Clearly states the verb 'Read' and the resource 'file from your workspace's storage', with a specific constraint ('requires Business-tier authorization'). Unambiguous and distinct from sibling tools.

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

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

Provides a usage condition (Business-tier authorization) but no guidance on when not to use or alternatives. Among siblings, no other file reading tool exists, so some direction is given but could be expanded.

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

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

With no annotations, the description carries full weight. It discloses that the previous token is invalidated (destructive behavior) and requires Business-tier authorization. This provides critical safety cues for an agent, though it could mention rate limits or reversibility.

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

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

Two sentences with no waste. The first sentence front-loads the action and result. Every word earns its place.

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

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

The description explains input, action, and authorization, but omits output structure and error cases. Given the lack of output schema, the agent is left guessing the response format. Adequate but 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?

The schema coverage is 0% and the description does not explain the 'service_account' parameter format (e.g., ID, email). The only clue is the phrase 'for a service account,' which is insufficient. The description should specify the accepted identifier type.

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

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

The description clearly states the action (rotate), resource (authentication token for a service account), and outcome (returns new token, invalidates old). It is specific, not a tautology, and distinguishes from sibling tools by its unique verb-resource combination.

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 specifies a prerequisite (Business-tier authorization) which helps the agent know when this tool is applicable. However, it does not explicitly provide alternative tools or when-not-to-use scenarios. The context is clear but lacks explicit usage boundaries.

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

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

With no annotations, the description partially covers behavioral context by stating the authorization requirement, but it does not disclose other behaviors such as whether the search is read-only, result format, or potential side effects.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It efficiently conveys the tool's purpose and a key constraint.

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 simplicity of the tool (one parameter, no output schema), the description is largely complete. It could hint at the return format, but the term 'search' commonly implies a list of results, so 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?

Schema coverage is 100% with the 'query' parameter described as 'Search terms.' The description adds no additional meaning beyond the schema, so baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'Search' with the resource 'your workspace's internal documentation', clearly distinguishing it from sibling tools like 'web_search' which targets external web sources. The authorization requirement is also mentioned.

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

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

No guidance is provided on when to use this tool versus alternatives. It mentions an authorization prerequisite but does not explain when not to use it or suggest other tools for related tasks.

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

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

No annotations are present, so the description must disclose behavior. It only states the authorization requirement, omitting idempotency, rate limits, error conditions, or other important behavioral 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 very short and to the point, but it lacks structure and fails to convey necessary information, making it under-specified rather than efficiently 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?

The tool has 3 required parameters with no schema descriptions, no output schema, and no annotations. The description provides almost no context about usage, constraints, or return values, making it insufficient 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?

Schema coverage is 0%, and the description does not explain the meaning or format of the parameters (to, subject, body). The description adds no value beyond the schema's field names.

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

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

Description clearly states the tool sends an email from the workspace address and notes the authorization requirement. However, it does not differentiate from sibling communication tools like send_slack_message.

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?

Only mentions the Business-tier authorization prerequisite, but provides no guidance on when to use this tool over alternatives or when not to use it.

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

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

No annotations are provided, so the description carries the full burden. It only mentions authorization requirements but does not disclose behaviors such as return values, error handling, formatting options, or rate limits. The agent lacks critical behavioral context for a messaging tool.

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. It could be improved by including more details without becoming verbose, but it is not wasteful.

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 zero parameter coverage, the description fails to provide sufficient context. It mentions authorization but lacks details on return values, expected message format, or behavior upon success/failure.

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 adds no meaning to the parameters. The schema defines 'channel' and 'text' as required strings but lacks descriptions; the description does not clarify format (e.g., channel ID vs name, markdown support) or 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 clearly states the verb 'Posts' and the resource 'a message to a Slack channel'. It distinguishes this tool from siblings like send_email or post_status_update by specifying Slack.

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

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

The description includes a usage condition ('Requires Business-tier authorization') but does not provide guidance on when to use this tool versus alternatives like send_email or web_search. No explicit exclusions or when-not-to-use advice.

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

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

With no annotations provided, the description effectively discloses behavioral traits: counting only business hours, default hours, timezone handling (wall-clock in calendar locality), and waiting for next opening. This is sufficient for a non-destructive calculation tool.

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

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

The description is concise at three sentences, with no redundant information. It efficiently conveys the tool's purpose, behavior, and key parameters in a well-structured manner.

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 6-parameter tool with no output schema or annotations, the description explains the core algorithm and defaults. However, it does not specify the return format (e.g., ISO date string) or address the undocumented parameters, leaving some gaps in completeness.

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

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

Schema coverage is 67% (4 of 6 parameters described). The description adds context about business hour defaults and start handling but does not cover the 'country' and 'subdivision' parameters, which likely relate to holiday calendars. The description partially compensates but leaves gaps.

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

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

The description clearly identifies the tool as calculating SLA due times using business hours, with a specific verb 'works out' and resource 'service-level agreement'. However, it does not explicitly differentiate from sibling tools like 'add_business_days' or 'business_days_between', which may have similar purposes.

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

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

The description explains when to use the tool and provides context (e.g., handling out-of-hours starts). However, it lacks explicit guidance on when not to use it or mention of alternative tools for similar calculations, leaving the agent to infer usage boundaries.

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?

States 'parsing only; nothing is scheduled or run' disclosing no side effects. Without annotations, this adequately covers safety, though return format or error behavior not specified.

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

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

Two sentences, clear and front-loaded with the core action. No wasted words.

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

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

For a single-parameter validation tool with no output schema, description is sufficient. Could mention return type (boolean or error) but not critical given simplicity.

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

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

Schema covers parameter fully with description and example. Description adds no extra semantic value beyond what schema provides, so baseline score 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?

Description uses specific verb 'checks whether...valid' against 'five-field cron expression', clearly separating from siblings like 'explain_cron_expression' and 'next_cron_occurrences' that do different 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?

Includes 'nothing is scheduled or run' clarifying what it does not do, but does not explicitly mention alternatives for semantic validation (e.g., validate_recurrence_rule) or suggest when 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?

No annotations are provided, so the description carries full burden. It discloses that the tool only parses and does not schedule, which is a key behavioral trait. It also hints at the domain (iCalendar) and that rules may be unsupported. For a simple validation tool, this is sufficient transparency.

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

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

The description consists of two concise sentences with no filler. Every phrase adds value: the purpose and the parsing-only note. Front-loaded 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?

For a one-parameter validation tool with no output schema and no annotations, the description covers the essential: what it does, its scope, and its read-only nature. It could optionally mention the return format (e.g., boolean or error), but this is a minor gap 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 has 100% description coverage for its single parameter 'rule', including an example. The tool description does not add any additional parameter information beyond what the schema provides. Baseline score of 3 applies per guidelines.

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

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

Description clearly states the verb 'check whether' and the resource 'iCalendar recurrence rule (RRULE)', and adds scope ('valid and supported', 'parsing only; nothing is scheduled'). This distinguishes it from siblings like 'explain_recurrence_rule' and 'next_recurrence_occurrences'.

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

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

The description explicitly states 'Parsing only; nothing is scheduled', which provides clear context for when to use (validation) and when not (actual scheduling). It implicitly differentiates from sibling tools, but does not name alternatives explicitly.

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

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

With no annotations, the description carries full burden. It states the tool runs a web search and requires Business-tier auth, but does not disclose behavioral traits such as idempotency, caching, rate limits, potential costs, or error conditions. This is insufficient for a search tool.

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

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

Two sentences, front-loaded with the main action, no extraneous words. Efficiently communicates purpose and auth requirement.

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

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

Given a simple tool with no output schema, the description provides core info (what, entity, auth). However, it lacks details on return structure ('ranked results' is vague) and does not elaborate on usage context. It is adequate but not comprehensive.

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

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

Schema coverage is 50% (only 'limit' described). The description adds no meaning beyond the schema: 'query' is self-explanatory but no constraints (e.g., max length), and 'limit' is already described. No additional context for the undocumented aspects of query.

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

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

The description clearly states the tool runs a web search and returns ranked results, with a specific verb and resource. It is distinct from all sibling tools, which are unrelated (e.g., business day calculations, invoice management).

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 mentions an authorization requirement ('Business-tier'), which is a prerequisite. However, it provides no explicit guidance on when to use this tool versus alternatives, though no direct alternative exists among siblings. Usage is implied by the tool name and 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?

Discloses draft status and authorization requirement, but does not describe potential side effects, error handling, or response format. With no annotations, more detail would be beneficial.

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

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

Two efficient sentences with no superfluous information, front-loaded with the main action.

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

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

Covers purpose, draft nature, and auth requirement, but omits return value and error scenarios. For a simple tool it is adequate but not fully complete.

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

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

Only restates parameter names ('Supply a title and the report body') without adding format, length, or example values. Schema coverage is 0%, so description should compensate more.

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

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

Clearly states verb (Write), resource (generated report), and target (connected workspace's reports area). Distinct from siblings like create_invoice or send_email.

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

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

Specifies that report is a draft requiring human review and Business-tier authorization, giving clear context for when to use.

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