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

No annotations are provided, so the description carries full burden. While 'mark as completed or incomplete' implies a mutation operation, it doesn't disclose important behavioral traits like whether this requires specific permissions, whether changes are reversible, what happens if some reminders don't exist, or any rate limits. The description is minimal and lacks operational context.

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

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

The description is a single, efficient sentence that communicates the core functionality without any wasted words. It's appropriately sized for a straightforward batch operation tool and gets directly to the point.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the tool returns, error conditions, or important behavioral constraints. While the schema covers parameters well, the operational context and results are completely undocumented, leaving significant gaps for an agent trying to use this tool effectively.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters ('reminders' array and 'completed' boolean). The description adds no additional parameter semantics beyond what's in the schema descriptions. The baseline of 3 is appropriate when the schema does all the parameter documentation work.

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 ('mark') and resource ('multiple reminders') with the specific action ('as completed or incomplete at once'). It distinguishes from single-item operations like 'complete_reminder' by specifying 'multiple reminders at once', but doesn't explicitly differentiate from other batch operations like 'batch_update_reminders'.

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. With siblings like 'complete_reminder' (single item), 'batch_update_reminders' (general batch updates), and 'update_reminder' (single item updates), there's no indication of when batch completion is preferred over individual operations or other batch methods.

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 of behavioral disclosure. It mentions efficiency but fails to disclose critical traits: whether this is a mutation (implied by 'create'), permission requirements, rate limits, error handling for partial failures, or what the response looks like. For a batch mutation tool with zero annotation coverage, this is a significant 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?

The description is appropriately sized and front-loaded: two concise sentences that directly state the purpose and key benefit. Every sentence earns its place by providing essential information without redundancy or fluff.

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

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

Given the complexity of a batch mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., auth needs, error handling), return values, or prerequisites. While the schema covers parameters well, the description doesn't adequately address the gaps for a tool that creates multiple resources.

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

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

Schema description coverage is 100%, with the schema fully documenting the 'reminders' parameter (array of reminders, max 100). The description adds no parameter-specific semantics beyond implying batch creation. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't detract either.

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

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

The description clearly states the tool's purpose: 'Create multiple reminders at once.' It specifies the verb ('create') and resource ('reminders'), and distinguishes it from the sibling 'create_reminder' by emphasizing batch capability. However, it doesn't explicitly mention the specific resource type (e.g., 'reminder objects') or differentiate from other batch operations like 'batch_update_reminders'.

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

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

The description provides clear context for when to use this tool: 'More efficient than creating one at a time.' This implicitly guides the agent to prefer this tool over 'create_reminder' for multiple creations. However, it lacks explicit exclusions (e.g., when not to use it) or alternatives for edge cases, and doesn't mention sibling tools like 'batch_update_reminders' for updates.

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 mentions efficiency but lacks critical behavioral details: it doesn't specify if this is a mutation (implied by 'update'), what permissions are required, whether updates are atomic or partial, error handling for invalid entries, or rate limits. For a batch mutation tool with zero annotation coverage, this is inadequate.

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 core purpose and followed by a usage benefit. Every word earns its place with zero waste, making it highly efficient and easy to parse.

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

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

Given the complexity of a batch mutation tool with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits (e.g., permissions, error handling), output format, or prerequisites. While the schema covers parameters well, the overall context for safe and effective use is incomplete.

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

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

Schema description coverage is 100%, with the 'reminders' parameter fully documented in the schema (array of reminder updates, max 100 items). The description adds no parameter-specific semantics beyond implying batch processing. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.

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

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

The description clearly states the verb ('update') and resource ('multiple reminders'), and specifies it's a batch operation. It distinguishes from the sibling 'update_reminder' by emphasizing 'multiple reminders at once' versus single updates. However, it doesn't explicitly name the sibling or detail functional differences beyond efficiency.

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

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

The description provides clear context for when to use this tool: 'More efficient than updating one at a time.' This implicitly suggests using it over the sibling 'update_reminder' for multiple updates. However, it doesn't explicitly name alternatives or state when not to use it (e.g., for single updates).

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but doesn't mention whether this requires authentication, what happens on success/failure, if it's idempotent, or any side effects (e.g., notifications). For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place in this minimal but complete statement.

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 this is a mutation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't address what the tool returns, error handling, permissions needed, or how it differs from similar sibling tools. For a tool that modifies data, more contextual information would be expected.

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, clearly documenting all three parameters (id, listName, completed). The description doesn't add any meaningful semantic context beyond what the schema already provides, such as explaining relationships between parameters or special constraints. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Mark a reminder as completed or incomplete') with the resource ('reminder'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this from sibling tools like 'update_reminder' or 'batch_complete_reminders', which could have overlapping functionality.

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 like 'update_reminder' (which might handle more fields) or 'batch_complete_reminders' (for multiple reminders). There's no mention of prerequisites, error conditions, or typical use cases beyond the basic action.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Create' implies a write/mutation operation, the description doesn't disclose important behavioral traits like required permissions, whether the operation is idempotent, what happens on duplicate names, error conditions, or what the response looks like. It provides only minimal context beyond the basic action.

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

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

The description is extremely concise at just 7 words, front-loading the essential information with zero wasted words. Every word earns its place, making it easy for an agent to quickly understand the 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?

For a creation/mutation tool with 7 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects, error handling, response format, or usage context. While the schema covers parameters well, the description fails to provide the broader context needed for effective 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?

With 100% schema description coverage, the input schema already documents all 7 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain relationships between parameters (like dueDate vs allDayDueDate), provide examples beyond the schema, or offer usage guidance for parameter combinations.

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 ('Create a new reminder') and the target resource ('in the specified list'), which provides a specific verb+resource combination. However, it doesn't differentiate this tool from its sibling 'batch_create_reminders', which appears to serve a similar purpose but with batch capability.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'batch_create_reminders' for single vs. multiple reminders, nor does it provide any context about prerequisites, constraints, or typical use cases.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates a new list but doesn't mention what happens on success/failure, whether it requires specific permissions, if there are rate limits, or how it interacts with existing lists (e.g., duplicate names). This leaves significant gaps for a mutation tool with zero annotation coverage.

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

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

The description is a single, clear sentence that efficiently communicates the core functionality without any wasted words. It's appropriately sized for a simple tool and front-loads the 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?

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., success confirmation, list ID), error conditions, or behavioral nuances. Given the complexity of creating a resource in a system like macOS Reminders, more context is needed for effective use.

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

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

The schema description coverage is 100%, with the single parameter 'name' fully documented in the schema. The description doesn't add any parameter-specific information beyond what's already in the schema (e.g., no examples, constraints, or context about naming conventions). This meets the baseline for high schema coverage but doesn't provide extra 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 action ('Create') and resource ('new reminder list in macOS Reminders app'), making the tool's purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'create_reminder' (which creates individual reminders) or 'rename_reminder_list' (which modifies existing lists), missing an opportunity for full sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites (e.g., needing macOS Reminders app access), when not to use it (e.g., for updating existing lists), or explicit alternatives among the siblings like 'rename_reminder_list' for modifying lists or 'create_reminder' for adding items to lists.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states 'This action cannot be undone,' which is crucial context about the destructive, permanent nature of the operation. However, it doesn't cover other important behavioral aspects like error conditions, permissions required, or what happens if the reminder doesn't exist.

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

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

The description is extremely concise with just two short sentences that are front-loaded with the core purpose. Every word earns its place, with no redundant or unnecessary information.

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

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

For a destructive tool with no annotations and no output schema, the description is minimally adequate. It covers the irreversible nature but lacks details about error handling, return values, or permissions. Given the high-stakes nature of deletion operations, more context would be beneficial.

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

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

Schema description coverage is 100%, with both parameters ('id' and 'listName') clearly documented in the schema. The description adds no additional parameter information beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting.

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

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

The description clearly states the action ('Delete') and resource ('a reminder'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'delete_reminder_list' or 'batch_delete_reminders' (if that existed), which would require mentioning it's for individual reminders rather than lists or batches.

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 like 'complete_reminder' or 'update_reminder', nor does it mention prerequisites such as needing the reminder's ID and list name. The warning about irreversibility is behavioral rather than usage guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates key traits: it's a destructive operation (implied by 'delete'), it cascades to all reminders in the list, and it's irreversible ('This action cannot be undone'). However, it lacks details on error handling, response format, or side effects beyond the deletion.

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—two sentences that are front-loaded with the core action and critical warning. Every word earns its place, with no redundant or vague language, making it easy for an agent to parse quickly.

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

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

Given the tool's complexity (destructive operation with cascading effects), no annotations, and no output schema, the description is minimally adequate. It covers the irreversible nature and scope but misses details like error cases (e.g., if the list doesn't exist), response format, or permissions required, leaving gaps for an agent to infer.

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

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

Schema description coverage is 100%, with the parameter 'name' fully documented in the schema. The description does not add any additional semantic context beyond what the schema provides (e.g., format examples, validation rules, or how 'name' is used). Baseline score of 3 is appropriate as the schema handles parameter documentation adequately.

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

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

The description clearly states the specific action ('Delete a reminder list and all its reminders') and distinguishes it from sibling tools like 'delete_reminder' (which deletes individual reminders) and 'list_reminder_lists' (which only lists them). It explicitly mentions the resource being affected (reminder list and its reminders).

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 like 'delete_reminder' (for individual reminders) or 'rename_reminder_list' (for modifying instead of deleting). It does not mention prerequisites, such as whether the list must exist or be empty, or contextual factors like permissions needed.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a read operation ('Get'), but doesn't mention authentication requirements, error conditions (e.g., what happens if the ID doesn't exist), rate limits, or what the return format looks like. For a tool with zero annotation coverage, this is insufficient behavioral context.

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

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

The description is perfectly concise - a single sentence that states exactly what the tool does with zero wasted words. It's front-loaded with the core purpose and doesn't contain any unnecessary information.

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

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

For a read operation with no annotations and no output schema, the description is incomplete. It doesn't explain what information is returned about the reminder, error handling, or authentication requirements. Given the context of multiple sibling tools for managing reminders, more guidance about when to use this specific retrieval tool would be valuable.

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

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

Schema description coverage is 100%, with both parameters ('id' and 'listName') clearly documented in the schema. The description mentions 'by its ID' which aligns with the 'id' parameter, but doesn't add any meaningful semantic context beyond what the schema already provides. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Get') and resource ('a single reminder by its ID'), making the purpose immediately understandable. It distinguishes this tool from batch operations and list retrieval tools like 'get_reminders', but doesn't explicitly differentiate from other single-reminder operations like 'complete_reminder' or 'update_reminder'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose 'get_reminder' over 'get_reminders' (for batch retrieval) or other sibling tools like 'complete_reminder' or 'update_reminder'. There's no context about prerequisites or typical use cases.

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

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

With no annotations provided, the description carries full burden but provides minimal behavioral context. It mentions filtering capabilities but doesn't disclose important traits like pagination behavior (implied by 'limit' parameter but not explained), sorting order, authentication requirements, rate limits, or what happens when no filters are applied. The description doesn't contradict annotations (none exist).

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

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

Single sentence efficiently conveys the core functionality with zero waste. Front-loaded with the main purpose followed by filter options. Every word earns its place with no redundant information.

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

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

For a read operation with 7 well-documented parameters but no annotations or output schema, the description is minimally adequate. It covers what the tool does but lacks context about behavioral traits, result format, error conditions, or relationship to sibling tools. The 100% schema coverage helps but doesn't compensate for missing behavioral transparency.

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

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

Schema description coverage is 100%, so the schema fully documents all 7 parameters. The description adds marginal value by listing the filter types (list, completion status, priority, date range, search text) but doesn't provide additional semantic context beyond what's already in the parameter descriptions. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the verb 'Get' and resource 'reminders' with the core functionality of filtering. It distinguishes from siblings like 'get_reminder' (singular) by implying it returns multiple items, but doesn't explicitly contrast with other list operations like 'list_reminder_lists'.

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

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

No explicit guidance on when to use this tool versus alternatives. While the filtering options suggest usage for querying multiple reminders, there's no mention of when to choose this over 'get_reminder' (for single items) or 'list_reminder_lists' (for list metadata).

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

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

With no annotations provided, the description carries the full burden. It discloses the read-only nature ('Get') and output structure, but lacks details on permissions, rate limits, error handling, or whether the operation is paginated. It adequately describes the core behavior but misses advanced operational context.

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

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

The description is two concise sentences with zero waste. The first sentence states the purpose and source, while the second specifies the return values. Every word adds value, and it's efficiently front-loaded with the core 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?

For a simple read-only tool with no parameters and no output schema, the description is reasonably complete. It covers what the tool does, where it operates, and what it returns. However, without annotations or output schema, it could benefit from more behavioral context like error cases or platform-specific constraints.

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

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

The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately focuses on output semantics ('Returns list names, IDs, and reminder counts') rather than redundant input details, earning a baseline 4 for zero-parameter tools.

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

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

The description clearly states the specific action ('Get all reminder lists'), resource ('from macOS Reminders app'), and output details ('Returns list names, IDs, and reminder counts'). It distinguishes itself from siblings like 'get_reminder' or 'get_reminders' by focusing on lists rather than individual reminders.

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

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

The description implies usage for retrieving all reminder lists, but provides no explicit guidance on when to use this versus alternatives like 'get_reminders' or 'create_reminder_list'. It doesn't mention prerequisites, exclusions, or specific scenarios where this tool is preferred.

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

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

With no annotations provided, the description carries full burden but only states it renames a list without disclosing behavioral traits. It doesn't mention permissions needed, whether the operation is idempotent, error conditions (e.g., if the list doesn't exist), or what happens on success (e.g., confirmation message). This leaves significant gaps for a mutation 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, efficient sentence that directly states the tool's purpose with no wasted words. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

Given this is a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns, error handling, or important behavioral context like idempotency or side effects, which are crucial for safe invocation.

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

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

Schema description coverage is 100%, with clear parameter descriptions in the schema ('Current name of the list', 'New name for the list'). The description adds no additional meaning beyond what the schema provides, such as format examples or constraints beyond min/max length, so it meets the baseline for high coverage.

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

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

The description clearly states the action ('Rename') and target resource ('an existing reminder list'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'update_reminder' or 'create_reminder_list' which might also involve name changes, so it doesn't reach the highest score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing the current name), exclusions, or compare it to siblings like 'update_reminder' or 'create_reminder_list' that might handle similar operations.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It adds one important behavioral trait: 'Only specified fields will be changed' (partial update behavior). However, it doesn't address critical aspects like authentication requirements, error conditions, whether updates are reversible, rate limits, or what happens when invalid data is provided. For a mutation tool with 9 parameters, this is insufficient behavioral context.

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

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

The description is perfectly concise - two clear sentences with zero wasted words. The first sentence establishes the core purpose, and the second adds important behavioral context about partial updates. Every word earns its place, and the information is front-loaded with the essential 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?

For a mutation tool with 9 parameters, no annotations, and no output schema, the description is inadequate. While concise, it doesn't address what the tool returns, error conditions, authentication requirements, or how it differs from sibling update tools. The 100% schema coverage helps with parameters, but the overall context for safe and effective use is incomplete.

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

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

Schema description coverage is 100%, meaning all parameters are documented in the schema itself. The description adds minimal value beyond the schema - it implies the tool performs partial updates ('Only specified fields will be changed'), which helps interpret how parameters interact. However, it doesn't provide additional semantic context about parameter relationships or constraints beyond what's already in the detailed 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 action ('Update') and resource ('an existing reminder's properties'), making the purpose immediately understandable. It distinguishes this from creation tools like 'create_reminder' by specifying 'existing reminder', but doesn't explicitly differentiate from other update tools like 'batch_update_reminders' or 'rename_reminder_list'.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'batch_update_reminders' for multiple updates or 'complete_reminder' for marking completion. It mentions 'Only specified fields will be changed' which is a behavioral note rather than usage guidance. No prerequisites or context for when this tool is appropriate are provided.

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