cron-parser

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

With no annotations, the description carries the burden of disclosing behavior. The verb 'List' implies a read-only operation, and the phrase 'with descriptions' suggests the output includes both expressions and explanations. However, it doesn't disclose any additional behavioral traits such as ordering, pagination, or whether the list is exhaustive, leaving room for ambiguity.

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

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

The description is a single, well-structured sentence with no wasted words. It front-loads the action ('List') and directly states the resource and what is included, making it easy to parse quickly.

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

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

The tool is simple with no parameters, no output schema, and no annotations. The description adequately conveys the purpose and implies the return structure (expressions and descriptions). It could explicitly state the output format (e.g., list of objects), but the current phrasing is sufficient for this low-complexity 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 has no parameters, so schema coverage is trivially 100%. With zero parameters, the description need not explain parameter semantics. It does add context by specifying that the expressions are 'commonly used' and paired with descriptions, which clarifies the intended content.

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

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

The description uses the specific verb 'List' with a clear resource ('commonly used cron expressions') and indicates that descriptions are included. This clearly distinguishes it from siblings like generate_cron, which creates new expressions, and explain_cron, which explains a specific expression.

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

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

The description says what the tool does but provides no guidance on when to use it versus alternatives. There is no mention of exclusions or conditions, and sibling tools are not referenced. For example, it doesn't clarify if users should use this to find examples versus generate_cron for custom expressions.

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 transparency burden. It states the action and the granularity of the output ('per-field differences'), implying a read-only, side-effect-free operation. It does not disclose error handling or the exact output format, but for a simple comparison tool, this is adequate. The description adds meaningful behavioral context beyond a naive 'compare'.

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 waste. It states the core action and expected output in 11 words, making it highly scannable 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 only two string parameters and no output schema or annotations. The description conveys the function and result shape at a high level ('per-field differences'), which is sufficient for an agent to select and invoke it. However, it does not detail the output structure (e.g., a map of field names to values/differences), leaving 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 each parameter ('first' and 'second') already described as cron expressions. The tool description's 'Compare two cron expressions' does not add further parameter-specific meaning, so the schema carries the weight. 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 ('Compare'), names the resource ('two cron expressions'), and states the outcome ('return per-field differences'). It clearly differentiates from sibling tools like explain_cron (which explains a single expression) and validate_cron (which validates).

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 when to use it: when you need to compare two cron expressions. It does not explicitly exclude alternatives or mention sibling tools, but the verb 'compare' naturally distinguishes it from explain, generate, validate, and next_runs. Slightly more explicit guidance (e.g., 'use instead of explain_cron when comparing two expressions') would make it a 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses the core output behavior (human-readable explanation, parsed fields) and adds preset support, but does not mention error handling, output format specifics, or explicitly confirm it is a read-only operation. This is adequate for a simple explain tool but lacks some transparency.

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

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

The description is two sentences, front-loaded with the purpose, and contains no superfluous words. Every sentence adds value, making it highly concise and well-structured.

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

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

For a simple one-parameter tool with high schema coverage, the description is sufficiently complete for selection and invocation. It does not describe return values, but no output schema exists and the behavior is straightforward. It covers the essential context 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?

The input schema already has 100% parameter description coverage with an example. The description adds the explicit note about @presets like @daily and @weekly, which slightly extends the schema's example. Since the schema does most of the work, this is a baseline 3 with minor added 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 clearly states the tool's function: explaining cron expressions in human-readable form and showing parsed fields. The verb 'explain' distinguishes it from sibling tools like validate_cron or generate_cron, and the mention of @presets adds specificity.

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 intended use is implied by the clear purpose, but the description does not explicitly contrast this tool with siblings or provide when/when-not guidance. There is no mention of alternatives or exclusions, only a straightforward statement of capability.

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 carries the full burden of behavioral disclosure. It does not mention the return format, validation behavior, how conflicting options are resolved, or any error cases, offering only a high-level action statement.

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 wording. However, it is so brief that it borders on under-specification, though it remains clean and appropriately compact for its core 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?

Given four parameters, nested objects, no output schema, and no annotations, the description is severely under-powered. It offers no examples, constraints on parameter combinations, or explanation of what constitutes a valid cron expression, making it incomplete for reliable tool invocation.

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

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

The description does not add meaning to any specific parameter beyond the generic phrase 'human-friendly options.' With schema description coverage at 50% and nested objects like 'at' lacking descriptions, the description should compensate but does not, leaving parameter semantics incomplete.

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 ('Generate a cron expression') and the input source ('human-friendly options'). This distinctly separates it from sibling tools like validate_cron or explain_cron, which imply different operations on cron expressions.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are no scenarios, prerequisites, or mentions of sibling tools, leaving the agent to infer usage context 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?

With no annotations provided, the description carries the full burden of disclosing behavioral details. It does disclose an important nuance: 'Uses standard Unix OR semantics for day fields.' This is non-obvious and valuable. However, it does not mention other behavioral aspects such as timezone handling, exact output format, or behavior for invalid expressions. The description provides a key detail but is not exhaustive.

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 sentences. The first sentence is action-oriented and front-loaded with the core purpose. The second sentence adds a crucial behavioral nuance without unnecessary filler. Every word earns its place; 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 (3 parameters, no output schema, no annotations), the description is moderately complete. It explains the core function and a key semantic, but it does not specify the output format (e.g., list of ISO timestamps) or error behavior. Since there is no output schema, the agent must infer the return structure from the description, which leaves room for ambiguity. The description is adequate but could be more thorough.

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

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

Schema description coverage is 100%, and each parameter (expression, from, count) already has a description in the schema. The tool description adds no new parameter-specific meaning beyond implying 'N' corresponds to 'count'. It does not refine the definition of 'expression' or 'from'. The baseline score of 3 is appropriate because the schema does the heavy lifting, and the description adds minimal parametric insight.

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

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

The description clearly states the tool's function: 'Get the next N scheduled run times for a cron expression.' This identifies a specific verb ('Get'), a resource ('run times'), and the input ('cron expression'). It distinguishes itself from siblings (common_crons, diff_cron, explain_cron, generate_cron, validate_cron) by focusing on computing future occurrences rather than generating, validating, or explaining cron expressions. The added note about Unix OR semantics further clarifies its behavior.

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

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

The description implies when to use the tool: whenever an agent needs to determine future run times for a cron expression. However, it does not explicitly mention alternatives or provide 'when not to use' guidance. Given the existence of sibling tools like validate_cron and generate_cron, explicit differentiation would improve the score. The use case is clear but not contrasted with alternatives.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It explicitly details the return format as {valid: bool, error?: string}, which tells the agent what to expect and implies a read-only, non-destructive operation. This adds useful behavioral context beyond a simple statement of purpose.

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

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

The description consists of two short, focused sentences with no fluff. It states the purpose and the return format efficiently, earning each word.

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 validation tool, the description is complete enough: it covers the purpose and explicitly provides the return shape, compensating for the lack of an output schema. It could optionally mention supported cron syntax variants or error handling details, but those are not essential for basic usage.

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

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

The input schema already provides a complete description of the 'expression' parameter with 100% coverage, so the baseline is 3. The tool description does not add any additional meaning or examples for the parameter, but the schema fully explains it.

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 checks if a cron expression is valid, using a specific verb and resource. This distinguishes it from sibling tools like generate_cron, explain_cron, and next_runs, which serve different purposes.

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

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

The description does not explicitly state when to use this tool or mention alternatives, but the purpose is so straightforward that usage is implied (i.e., when validation is needed). No exclusions or alternative comparisons are provided.

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