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

Annotations provide readOnlyHint=false (mutation), openWorldHint=true (flexible inputs), idempotentHint=true (safe to retry), and destructiveHint=false (non-destructive). The description adds that it 'marks as completed,' which aligns with annotations but doesn't provide extra behavioral context like rate limits, authentication needs, or what 'completed' entails (e.g., archiving). No contradiction with annotations.

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

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

The description is front-loaded with the core purpose, followed by structured sections (Args, Returns, Examples). It's appropriately sized, though the Examples are somewhat redundant and could be more illustrative. No wasted sentences.

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 annotations cover mutation and idempotency, and an output schema exists (Returns mentions JSON), the description is moderately complete. However, it lacks context on error handling, side effects, or how it fits with siblings, leaving gaps for a tool that modifies task state.

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

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

Schema description coverage is 0%, but the description includes an Args section detailing task_id and project_id with minimal semantics ('ID of the task/project'). This compensates somewhat, but it doesn't explain format, sourcing, or relationships beyond what's implied. With 0% coverage, baseline might be lower, but the Args add basic meaning.

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 TickTick task as completed') and identifies the resource ('task'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from siblings like ticktick_update_task (which might also handle completion) or ticktick_delete_task (another task modification).

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 task), exclusions, or comparisons to siblings like ticktick_update_task (which might handle partial updates including completion). The examples are generic and don't clarify context.

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

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

Annotations already indicate this is a write operation (readOnlyHint: false) and not destructive or idempotent. The description adds valuable context beyond annotations: it explains the default behavior (tasks go to Inbox if no project_id), provides concrete examples of usage, and describes the return format. However, it doesn't mention authentication needs, rate limits, or error conditions.

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 well-structured and efficiently organized: a clear purpose statement, parameter documentation with examples, return value explanation, and practical usage examples. Every section adds value without redundancy, and 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?

Given this is a creation tool with no destructive annotations and an output schema exists (returns JSON with success status and task details), the description provides excellent completeness. It covers purpose, all parameters with semantics, usage examples, return format, and references to sibling tools. The combination of description and annotations gives the agent everything needed to use this tool correctly.

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

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

With 0% schema description coverage (the schema has no descriptions at the top level, only within the nested CreateTaskInput), the description carries the full burden. It provides excellent parameter semantics: it lists all parameters with clear explanations, examples of values, default behaviors, and even includes practical examples showing how natural language requests map to parameters.

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

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

The description clearly states the specific action ('Create a new task in TickTick') and distinguishes it from siblings like update_task, complete_task, and delete_task by focusing on creation. It specifies the resource (task) and key parameters, 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 when to use this tool (creating tasks) and mentions using ticktick_list_projects first to get project_id, which is helpful guidance. However, it doesn't explicitly state when NOT to use it (e.g., vs. update_task for existing tasks) or name specific alternatives among siblings.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, but the description adds valuable context by emphasizing 'This action cannot be undone,' which reinforces the irreversible nature beyond the annotation. It does not mention rate limits, auth needs, or side effects, but the added warning is helpful.

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 well-structured with clear sections (description, Args, Returns, Examples) and front-loaded key information. The examples are relevant but could be more concise; overall, it avoids unnecessary verbosity.

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 destructive nature and lack of schema descriptions, the description compensates well with parameter documentation and a warning. The output schema exists (Returns section mentions JSON), so return values need not be detailed. It covers essential aspects but could improve by addressing authentication or error handling.

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

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

Schema description coverage is 0%, but the description includes an Args section that documents both task_id and project_id parameters, adding meaning beyond the bare schema. However, it does not explain parameter relationships or provide format examples, keeping it at baseline adequacy.

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 ('permanently delete') and resource ('a TickTick task'), distinguishing it from siblings like complete_task, update_task, or get_task. The verb 'delete' is precise and unambiguous.

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

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

The description implies usage context by stating the action is permanent and irreversible, which helps differentiate from non-destructive siblings. However, it does not explicitly name when to use alternatives (e.g., complete_task vs. delete_task) or specify prerequisites like authentication.

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

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

Annotations already provide strong behavioral hints (readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true), covering safety and idempotency. The description adds minimal context beyond this, such as specifying it returns 'full details' including timestamps, but does not elaborate on error conditions, rate limits, or authentication needs. With annotations doing heavy lifting, a baseline 3 is appropriate.

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

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

The description is well-structured with clear sections (purpose, Args, Returns, Examples) and front-loaded the core functionality. It avoids redundancy, but the 'Args' section could be more integrated into the flow rather than a separate block, slightly reducing efficiency.

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

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

Given the tool's low complexity (1 parameter object with 2 fields), rich annotations, and the presence of an output schema (implied by 'Returns: str: JSON object'), the description is mostly complete. It covers purpose, parameters, returns, and usage examples, though it lacks details on error handling or authentication, which are minor gaps.

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

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

Schema description coverage is 0%, but the description compensates by listing both parameters (task_id and project_id) and their purposes in the 'Args' section, adding meaning beyond the bare schema. However, it does not explain parameter constraints (e.g., format of IDs) or interactions, so it only partially addresses the coverage gap, warranting a baseline score.

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

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

The description clearly states the specific action ('Get full details') and resource ('a specific TickTick task by ID'), distinguishing it from siblings like list_tasks (which retrieves multiple tasks) or update_task (which modifies tasks). The verb 'Get' combined with 'full details' precisely communicates 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 for when to use this tool ('when you have a task ID and need its current details'), which implicitly distinguishes it from list_tasks (for multiple tasks without IDs) and other siblings. However, it does not explicitly state when NOT to use it or name alternatives, preventing a perfect score.

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

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

Annotations already cover key behavioral traits (readOnlyHint: true, destructiveHint: false, etc.), but the description adds valuable context by specifying the return format (JSON array with id, name, color, closed) and that project IDs are needed for other tools. It doesn't contradict annotations and enhances understanding beyond the structured hints.

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 well-structured and front-loaded with the core purpose, followed by return details, usage guidelines, and examples. Every sentence adds value without redundancy, and it's appropriately sized for a tool with no parameters but important output semantics.

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 (0 parameters, annotations covering safety, and an output schema), the description is complete. It explains what the tool does, when to use it, the return format, and how it integrates with siblings. No gaps exist for this read-only listing 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?

There are 0 parameters, and schema description coverage is 100%, so the baseline is high. The description doesn't need to explain parameters, but it implicitly confirms there are no inputs by focusing on the output and usage. It adds value by clarifying the tool's scope without parameter details.

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

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

The description clearly states the verb ('List') and resource ('all TickTick projects (task lists) in the user's account'), distinguishing it from sibling tools like ticktick_list_tasks (which lists tasks, not projects). It specifies that it returns projects with IDs and names, making the purpose specific and unambiguous.

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

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

The description explicitly provides usage scenarios with 'Use when:' examples, such as 'What projects/lists do I have in TickTick?' and needing a project ID for other tools. It distinguishes this tool from siblings by indicating it's for listing projects, not tasks, and guides on using the output with other tools like creating or listing tasks.

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

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

Annotations already provide comprehensive behavioral hints (readOnlyHint: true, destructiveHint: false, etc.), so the bar is lower. The description adds valuable context about the prerequisite (need project ID) and clarifies it fetches 'all active tasks' rather than filtered subsets, which isn't covered by annotations. No contradictions with annotations.

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

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

Well-structured with clear sections (description, args, returns, examples) and front-loaded purpose. The examples are helpful but slightly verbose; every sentence earns its place by adding practical guidance or clarifying usage.

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

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

Given the tool's low complexity (single parameter), rich annotations covering safety and behavior, and the presence of an output schema (described in the returns section), the description is complete. It provides purpose, usage guidance, parameter context, and output format without redundancy.

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

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

Schema description coverage is 0%, but the description compensates by explaining the single parameter's purpose ('Project ID to list tasks from') and providing guidance on how to obtain it (via ticktick_list_projects). However, it doesn't add format details or constraints beyond what's implied. With only one parameter, this meets baseline expectations.

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 all active tasks') and resource ('in a specific TickTick project'), distinguishing it from siblings like ticktick_get_task (single task) and ticktick_list_projects (projects rather than tasks). It precisely defines scope with 'active tasks' and 'specific project'.

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

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

Explicitly provides when-to-use guidance: 'Use ticktick_list_projects first if you don't know the project ID' and includes two concrete examples ('Show me my tasks in the Work project' and 'What's on my to-do list?'). This clearly differentiates it from alternatives and provides practical application scenarios.

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

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

The description adds valuable behavioral context beyond annotations: it explains the fetch-then-merge approach ('Fetches the current task first, then applies your changes on top'), clarifies that unspecified fields are preserved, and provides format examples for due dates. Annotations cover idempotency and non-destructive nature, but the description adds practical implementation details.

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?

Perfectly structured with clear sections: purpose statement, behavioral explanation, Args with parameter details, Returns, and Examples. Every sentence adds value with zero redundancy. The information is front-loaded with the core update behavior explained first.

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?

Complete for an update tool with good annotations and output schema. The description covers purpose, behavioral approach, all parameters with semantics, return format, and practical examples. With annotations covering safety profile (non-destructive, idempotent) and output schema presumably documenting return structure, the description provides excellent contextual coverage.

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

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

With 0% schema description coverage (context signals show Parameter count: 1, Required parameters: 1), the description carries full burden. It provides clear semantics for all parameters: explains task_id and project_id are required, documents optional fields with examples (due date format) and priority mapping (0=None, 1=Low, 3=Medium, 5=High). This fully compensates for the schema coverage gap.

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

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

The description clearly states the verb 'Update' and resource 'existing TickTick task', distinguishing it from siblings like create_task, delete_task, and complete_task. It specifies that only provided fields are changed, which differentiates it from a full replacement operation.

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

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

The description implies usage through examples like changing due dates or priorities, but doesn't explicitly state when to use this vs. alternatives like complete_task or delete_task. It mentions fetching current task first, which provides some context but not explicit guidance on tool selection.

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