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. While it mentions the tool 'creates' (implying mutation) and lists supported features, it doesn't address critical behavioral aspects like authentication requirements, error conditions, whether events are immediately saved, what happens with invalid inputs, or rate limits. The description is insufficient 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 efficiently structured in a single sentence that front-loads the core purpose and follows with key supported features. Every element serves a purpose, though it could potentially be more concise by removing redundant information already covered in the schema.

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 incomplete. It doesn't address what happens after creation (success response, error handling), doesn't mention authentication or permission requirements, and provides minimal guidance on usage context. The description leaves significant gaps for an agent to understand the full operational context.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters thoroughly. The description adds minimal value beyond the schema by mentioning that location, notes, attendees, and alerts are 'optional' features, but doesn't provide additional semantic context about parameter interactions or usage patterns beyond what's in the 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 specific action ('Create a new event'), the target resource ('in Apple Calendar'), and distinguishes it from siblings by specifying the type of operation (creation vs deletion, listing, updating). It mentions key event types ('all-day and timed events') which helps differentiate from other calendar 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?

The description provides no guidance on when to use this tool versus alternatives like calendar_update_event or calendar_list_events. It mentions what the tool supports but gives no context about prerequisites, appropriate scenarios, or when other tools might be more suitable.

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. While it mentions that deletion can be done via eventId (most reliable) or title search, it doesn't disclose critical behavioral traits: whether deletion is permanent/reversible, what permissions are required, error handling for missing events, or confirmation prompts. For a destructive operation 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, with the core purpose stated first followed by parameter usage guidance. Both sentences earn their place by providing essential information without redundancy or fluff. It's efficient and well-structured for quick comprehension.

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 destructive mutation tool with no annotations and no output schema, the description is incomplete. It lacks information on behavioral consequences (e.g., permanence, permissions), error responses, or what happens upon successful deletion. While parameter coverage is adequate via the schema, the overall context for safe and effective use is insufficient.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds minimal value beyond the schema by reinforcing that eventId is 'most reliable' and that date is 'optional when using title search', but doesn't provide additional syntax, format details, or edge cases. This meets the baseline of 3 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 tool's purpose with a specific verb ('Delete') and resource ('calendar event'), making it immediately understandable. It distinguishes from siblings like calendar_update_event by specifying deletion rather than modification. However, it doesn't explicitly contrast with other deletion tools (though none exist in the sibling list), keeping it at 4 rather than 5.

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

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

The description provides clear context on when to use different parameters (eventId vs. title with date filter), which helps guide usage. It doesn't explicitly state when NOT to use this tool or name alternatives for deletion scenarios, but the parameter guidance is sufficient for basic decision-making. No misleading information is present.

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 analyzing 'existing events' and returning 'free gaps,' which gives some context about what the tool does, but it lacks details on permissions needed, rate limits, whether it accesses multiple calendars by default, or how it handles overlapping events. For a tool with no annotation coverage, this leaves significant behavioral aspects unclear.

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: it starts with the core purpose ('Find available time slots...'), followed by a clarifying sentence ('Analyzes existing events...'). Both sentences earn their place by adding value without redundancy, making it efficient and well-structured.

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

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

Given the tool's moderate complexity (5 parameters, no output schema, no annotations), the description is somewhat complete but has gaps. It explains the high-level function but lacks details on behavioral aspects like error handling or output format. Without annotations or an output schema, the description should do more to cover these areas, making it adequate but not fully comprehensive for the context.

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

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

Schema description coverage is 100%, meaning all parameters are documented in the schema. The description doesn't add any specific parameter details beyond what's in the schema (e.g., it doesn't explain the format of 'date' or constraints on 'duration' beyond the schema's '15-480'). With high schema coverage, the baseline is 3, as the description doesn't compensate with extra semantic value, but it also doesn't detract.

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: 'Find available time slots in your calendar for scheduling meetings.' It specifies the verb ('find') and resource ('available time slots'), and distinguishes it from sibling calendar tools like 'calendar_list_events' by focusing on free time analysis rather than event listing. However, it doesn't explicitly differentiate from non-calendar siblings like 'notes_search' or 'reminders_add', which is why it's not a perfect 5.

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

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

The description implies usage context by stating it 'analyzes existing events and returns free gaps,' suggesting it should be used when looking for open slots in a calendar. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'calendar_list_events' for viewing events or 'calendar_create_event' for scheduling, nor does it mention any exclusions or prerequisites. The guidance is present but not comprehensive.

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 adds some context beyond the input schema: 'Returns up to 100 events' clarifies output limits, and 'Can filter by specific calendar' hints at optional filtering. However, it lacks details on permissions, rate limits, pagination, error handling, or what happens if no events are found, leaving gaps for a mutation-free but data-retrieval 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 extremely concise and front-loaded: two sentences that directly state the tool's function and key constraints. Every word earns its place, with no redundancy or fluff. It efficiently communicates the core purpose and output limit without unnecessary elaboration.

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 moderate complexity (4 parameters, no annotations, no output schema), the description is partially complete. It covers the basic action and output limit but misses contextual details like error scenarios, authentication needs, or how results are structured. Without an output schema, it should ideally hint at return values (e.g., event details), but it only mentions quantity, leaving gaps in usability.

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, providing clear details for all 4 parameters (e.g., formats, defaults). The description adds minimal semantic value: 'within a date range' and 'filter by specific calendar' loosely map to parameters but don't enhance understanding beyond the schema. With high schema coverage, the baseline is 3, and the description doesn't significantly compensate or add new insights.

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: 'List calendar events within a date range. Can filter by specific calendar.' This specifies the verb ('List'), resource ('calendar events'), and scope ('date range', 'filter by specific calendar'). However, it doesn't explicitly distinguish this tool from sibling tools like 'calendar_find_free_time' or 'reminders_list', which prevents a score of 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'calendar_find_free_time' for availability checks or 'reminders_list' for reminders instead of calendar events. There's no context about prerequisites, such as needing calendar access, or when not to use it (e.g., for creating or updating events).

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 states 'update an existing calendar event' which implies mutation, but doesn't disclose critical traits like required permissions, whether changes are reversible, error handling (e.g., invalid eventId), or rate limits. 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 front-loads the core action ('update an existing calendar event') and specifies key modifiable attributes. Every word earns its place with no redundancy or unnecessary elaboration, making it highly concise and well-structured for quick comprehension.

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 mutation tool with no annotations and no output schema, the description is incomplete. It lacks information on behavioral aspects (e.g., permissions, side effects), response format, error conditions, and usage context. While the schema covers parameters well, the overall context for safe and effective tool invocation is insufficient.

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 lists modifiable fields (title, dates, location, notes), which aligns with the input schema parameters. However, schema description coverage is 100%, so the schema already fully documents all 6 parameters. The description adds minimal value beyond what's in the schema, meeting the baseline for high coverage without providing additional semantic context (e.g., format details 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 'update' and resource 'calendar event', specifying what can be modified (title, dates, location, notes). It distinguishes from siblings like calendar_create_event and calendar_delete_event by focusing on modification rather than creation or deletion. However, it doesn't explicitly differentiate from calendar_list_events or other calendar tools beyond the basic action.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing event ID), when not to use it (e.g., for creating new events), or direct comparisons to siblings like calendar_create_event or calendar_delete_event. Usage is implied by the action but lacks explicit context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adequately conveys that this is a mutation operation ('Append content') and provides some behavioral context about the search approach reliability. However, it doesn't disclose important behavioral traits like whether the append operation is reversible, what happens if multiple notes match the title, or any rate limits/authentication requirements that might 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 perfectly concise with just two sentences that each earn their place. The first sentence states the core purpose, and the second provides essential usage guidance about parameter approaches. There's zero wasted text and the information is front-loaded appropriately.

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 provides adequate basic information but has significant gaps. It covers the what and how of the operation but doesn't address important contextual aspects like error conditions, response format, or what happens when the append succeeds/fails. The description is complete enough to understand the tool's basic function but insufficient for robust agent usage without additional context.

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

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

With 100% schema description coverage, the input schema already documents all 4 parameters thoroughly. The description adds some value by emphasizing the reliability difference between noteId and title approaches and mentioning the optional folder parameter's purpose, but doesn't provide significant additional semantic context beyond what's already in the 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 specific action ('Append content') and resource ('to an existing note'), distinguishing it from sibling tools like notes_create (which creates new notes) and notes_search (which searches notes). It provides a complete verb+resource+scope statement that leaves no ambiguity about the tool's function.

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

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

The description provides clear context about when to use different parameter approaches ('Can find by note ID (most reliable) or by title with optional folder filter'), which helps the agent understand alternative usage patterns. However, it doesn't explicitly state when NOT to use this tool versus alternatives like notes_create or notes_update, nor does it mention prerequisites like needing an existing note.

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 mentions HTML formatting support, but fails to address critical aspects like required permissions (e.g., Apple Notes app access), mutation effects (creation is irreversible), error handling, or rate limits. 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 front-loads the core purpose ('Create a new note') and includes essential details (app, title/body content, HTML support) without redundancy. Every word earns its place.

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

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

For a mutation tool with no annotations and no output schema, the description is adequate but incomplete. It covers the basic purpose and HTML feature, but lacks details on behavioral traits (e.g., permissions, errors) and output expectations, which are critical given the tool's complexity and lack of structured metadata.

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 three parameters (title, body, folder). The description adds minimal value by mentioning HTML formatting for the body, which is already covered in the schema's description for the body parameter. This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('Create a new note'), resource ('in Apple Notes app'), and scope ('with title and body content'), distinguishing it from sibling tools like notes_append (which modifies existing notes) and notes_search (which retrieves notes).

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 creating notes with HTML formatting, but lacks explicit guidance on when to use this tool versus alternatives like notes_append (for adding to existing notes) or calendar_create_event (for different resource types). No exclusions or prerequisites 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?

With no annotations provided, the description carries full burden. It discloses key behavioral traits: it's a read operation (implied by 'Search'), returns up to 100 notes with excerpts, and supports filtering. However, it doesn't mention permissions, rate limits, or pagination behavior beyond the limit parameter.

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 with two sentences that each earn their place: first sentence defines the core functionality, second sentence adds important behavioral constraints. No wasted words, front-loaded with 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 search tool with 3 parameters and 100% schema coverage but no output schema, the description is reasonably complete. It explains what gets searched, filtering capability, and result limits. However, without an output schema, it could better describe the return format beyond 'notes with excerpts'.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds marginal value by mentioning 'filtering by folder' and 'up to 100 notes' which relates to the limit parameter, but doesn't provide additional semantic context beyond what's in the schema.

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

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

The description clearly states the specific action ('Search notes by keyword'), target resource ('notes'), and scope ('in title or body'), distinguishing it from siblings like notes_create or notes_append. It explicitly mentions what gets searched and what is returned.

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 (searching notes by keyword with optional folder filtering) but doesn't explicitly state when not to use it or name alternatives. It distinguishes from non-search siblings but doesn't compare to reminders_search or other search tools.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions the creation action, it doesn't address important behavioral aspects like required permissions, whether the operation is idempotent, error handling, or what happens on success/failure. The description only covers basic functionality without 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 efficiently communicates the tool's purpose and capabilities. Every word earns its place, with no redundant information or unnecessary elaboration.

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 tool with no annotations and no output schema, the description provides adequate basic information but lacks completeness. It doesn't address what happens after creation, error scenarios, or integration considerations with the Apple Reminders ecosystem. The description covers what the tool does but not the full context of its operation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description lists the supported fields but doesn't add meaningful semantic context beyond what's in the schema descriptions. It provides a high-level overview but no additional parameter insights.

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 ('Create a new reminder') and target resource ('in Apple Reminders app'), distinguishing it from sibling tools like reminders_list or reminders_complete. It goes beyond the tool name by specifying the app context and supported fields.

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 creating reminders with specific attributes but doesn't explicitly state when to use this tool versus alternatives like notes_create or calendar_create_event. No guidance is provided about prerequisites, error conditions, or when not to use this tool.

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 the tool can mark reminders as completed and how to find them, but it does not disclose critical behavioral traits such as whether this action is reversible, what permissions are required, or what happens if multiple reminders match the title. For a 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 front-loaded with the main purpose in the first sentence and adds necessary details in the second, with no wasted words. It is appropriately sized and structured for the tool's complexity.

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

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

Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description covers the purpose and basic usage but lacks details on behavioral aspects like error handling or return values. It is minimally viable but has clear gaps in transparency and completeness for a mutation 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 adds some meaning by noting that reminderId is the 'most reliable method' and that list is 'optional' to narrow search when using title, but the input schema already has 100% description coverage with clear parameter details. This provides marginal value beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Mark a reminder as completed') and the resource ('a reminder'), distinguishing it from sibling tools like reminders_add, reminders_list, and reminders_search. It specifies the exact operation rather than being vague or tautological.

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 on when to use this tool by explaining it can find reminders by ID or title with optional list filtering, but it does not explicitly mention when not to use it or name alternatives like reminders_search for finding reminders without completing them. This gives good guidance but lacks explicit exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: it's a read operation (implied by 'List'), returns up to 100 reminders, and includes default behaviors for parameters. However, it lacks details on error handling, authentication needs, or rate limits, which are important for a tool with no 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 front-loaded with the core purpose and includes essential details in a single, efficient sentence. Every part earns its place by clarifying scope, filtering options, and return limits 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 moderate complexity (3 parameters, no annotations, no output schema), the description is adequate but incomplete. It covers the basic operation and parameters but lacks details on output format, error cases, or integration context, which would help an agent use it correctly in broader workflows.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value by mentioning filtering by list name and completion status, but does not provide additional semantics beyond what the schema specifies (e.g., format of list names or completion logic).

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 ('List reminders') and resource ('from Apple Reminders app'), distinguishing it from siblings like 'reminders_add' (create) and 'reminders_search' (search). It explicitly mentions filtering capabilities and the return limit, making the purpose unambiguous.

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

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

The description provides clear context for usage by mentioning optional filtering by list name and completion status, and it implicitly contrasts with 'reminders_search' by focusing on listing rather than searching. However, it does not explicitly state when to use this tool versus alternatives like 'reminders_search' or 'calendar_list_events'.

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. While it mentions search functionality and filtering options, it doesn't disclose important behavioral traits such as whether this is a read-only operation (implied but not stated), pagination behavior (only mentions 'limit' parameter), error handling, authentication requirements, or rate limits. For a search tool with zero annotation coverage, this leaves significant 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 extremely concise (two sentences) and front-loaded with the core purpose. Every word earns its place—the first sentence states the main action and scope, while the second adds key filtering capabilities without redundancy. No wasted words or unnecessary elaboration.

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 moderate complexity (search with filtering), 100% schema coverage for inputs, but no annotations and no output schema, the description is adequate but incomplete. It covers the basic purpose and filtering options but lacks behavioral context (e.g., read-only nature, result format, error cases) that would be helpful for an AI agent, especially without annotations to fill those gaps.

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

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

Schema description coverage is 100%, so the schema already fully documents all 4 parameters (query, list, includeCompleted, limit) with their types, descriptions, defaults, and constraints. The description adds minimal value beyond the schema, only implying that 'query' searches in 'title or notes' and that filtering by 'list and completion status' is supported, which is already clear from parameter names and 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 specific action ('Search reminders by keyword in title or notes') and distinguishes it from sibling tools like 'reminders_list' (which presumably lists all reminders without search) and 'reminders_add' (which creates reminders). It specifies the resource (reminders) and scope (search by keyword in title/notes).

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 ('Search reminders by keyword in title or notes') and mentions filtering capabilities ('Supports filtering by list and completion status'). However, it doesn't explicitly state when NOT to use it (e.g., vs. 'reminders_list' for browsing all reminders without search) or name specific alternatives, though the context is clear enough for effective usage.

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