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 that it 'Creates a new project' and returns a 'confirmation message with the created project ID,' but lacks details on permissions required, error handling, rate limits, or whether the operation is idempotent. This is a significant gap 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 well-structured and front-loaded with the core purpose, followed by clear sections for 'Args' and 'Returns.' Every sentence adds value without redundancy, making it 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 tool's complexity (a mutation with 3 parameters), no annotations, and an output schema present (which covers return values), the description is moderately complete. It explains parameters well but lacks behavioral context like error cases or usage guidelines. The output schema reduces the need to detail returns, but overall completeness is adequate with clear 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?

The description adds meaningful context beyond the input schema, which has 0% description coverage. It explains that 'name' is the project name, 'color' is optional with examples (e.g., 'red', '#ff9900'), and 'parent_id' is for nested projects. This compensates well for the schema's lack of descriptions, though it doesn't cover all possible nuances like format constraints for 'parent_id'.

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 ('Create') and resource ('new project in Todoist'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'todoist_update_project' or 'todoist_get_project', which would require a more specific statement about when to create versus update or retrieve.

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., authentication), when not to use it (e.g., for updating existing projects), or refer to sibling tools like 'todoist_update_project' for modifications or 'todoist_get_projects' for listing.

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 the creation action and return format, but fails to describe critical traits like authentication requirements, rate limits, error handling, or whether the operation is idempotent. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is well-structured with a brief purpose statement followed by organized Args and Returns sections. Every sentence adds value, though the 'Args' and 'Returns' headers could be integrated more seamlessly. It avoids redundancy and is appropriately sized 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 (6 parameters, 1 required), no annotations, and an output schema present (which covers return values), the description is partially complete. It explains parameters well but lacks behavioral context like error cases or dependencies. The output schema reduces the need to detail return values, but more guidance on usage and transparency would improve completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It provides clear semantic explanations for all 6 parameters, including examples for due_date (e.g., 'tomorrow', '2024-01-15'), priority range (1-4 with 4 as highest), and format for labels (list of names). This adds substantial value beyond the bare schema, though it could benefit from more detail on project_id format or label 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 specific action ('Create a new task') and resource ('in Todoist'), distinguishing it from sibling tools like todoist_complete_task, todoist_update_task, and todoist_get_tasks. The verb+resource combination 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?

No explicit guidance is provided on when to use this tool versus alternatives like todoist_update_task for modifying existing tasks or todoist_get_tasks for retrieving tasks. The description lacks context about prerequisites, such as whether a project must exist before assigning a task to it, or when to use this versus other creation tools like todoist_add_project.

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 the action ('Mark as complete') which implies a mutation, but doesn't mention permission requirements, whether completion is reversible, side effects on related data, or rate limits. The return value description is minimal.

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 front-loaded with the core purpose in the first sentence, followed by structured Args/Returns sections. Every sentence earns its place with no wasted words, making it easy to scan and understand 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?

For a mutation tool with no annotations, the description covers the basic purpose and parameter meaning adequately. However, it lacks important behavioral context about permissions, reversibility, and side effects. The existence of an output schema reduces the need to detail return values, but more mutation-specific guidance would be helpful.

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 provides clear semantic meaning for the single parameter ('The ID of the task to complete') that goes beyond the schema's basic type information. With 0% schema description coverage and only one parameter, this adequately compensates for the schema's lack of documentation.

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

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

The description clearly states the specific action ('Mark a task as complete') and identifies the resource ('task'), distinguishing it from sibling tools like todoist_add_task or todoist_update_task. It uses precise verb+resource phrasing 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 implies usage context (when you want to complete a task) but provides no explicit guidance on when to use this vs alternatives like todoist_update_task (which might also mark completion) or when not to use it. No prerequisites or sibling tool comparisons are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Delete' implies a destructive mutation, the description doesn't specify whether this action is reversible, requires specific permissions, has side effects (e.g., deleting associated tasks), or includes confirmation prompts. The return statement mentions a confirmation message but lacks detail on format or error handling.

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

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

The description is extremely concise and well-structured: a clear purpose statement followed by dedicated Args and Returns sections. Every sentence earns its place, with no redundant or verbose language. It's front-loaded with the core action and efficiently organized for quick parsing.

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 mutation with no annotations) and the presence of an output schema (which handles return values), the description is minimally adequate. It covers the basic action and parameter but lacks critical behavioral context like irreversibility or permissions. For a delete operation, more safety and consequence details would improve completeness.

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

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

With 0% schema description coverage and only one parameter, the description effectively compensates by explaining 'project_id' as 'The ID of the project to delete.' This adds essential meaning beyond the bare schema, clarifying the parameter's role and format expectation. However, it doesn't specify ID format (e.g., numeric vs. string) or validation rules.

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') and resource ('a project by ID'), distinguishing it from sibling tools like todoist_get_project (read) and todoist_update_project (modify). It provides a precise verb+resource combination 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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing project ID), exclusions, or comparisons with siblings like todoist_delete_task. The agent must infer usage from the name alone, which is insufficient for optimal tool selection.

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 deletes a task, implying a destructive mutation, but lacks details on permissions needed, whether deletion is permanent or reversible, error handling (e.g., if task_id is invalid), or rate limits. This is inadequate for a mutation tool without 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 action ('Delete a task by ID') and uses a structured format with 'Args:' and 'Returns:' sections. Every sentence adds value without redundancy, 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 tool's complexity (a destructive mutation), lack of annotations, and presence of an output schema (implied by 'Returns:'), the description is minimally adequate. It covers the basic action and parameter but misses critical behavioral details like safety warnings or error cases, leaving gaps for an AI 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?

The description adds meaningful context for the single parameter 'task_id' by specifying it's 'The ID of the task to delete,' which clarifies its role beyond the schema's type information. Since schema description coverage is 0% and there's only one parameter, this effectively compensates, though it doesn't detail format or validation rules.

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 task by ID'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'todoist_delete_project' or 'todoist_complete_task' beyond the obvious resource difference, missing explicit sibling distinction.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention prerequisites (e.g., task must exist), exclusions (e.g., cannot delete completed tasks if applicable), or comparisons to siblings like 'todoist_complete_task' for task completion instead of deletion.

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 the tool retrieves project details but doesn't disclose behavioral traits such as whether it's a read-only operation, authentication requirements, error handling, or rate limits. For a tool with no annotation coverage, this is a significant gap in transparency, though it doesn't contradict any 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 appropriately sized and front-loaded, starting with the core purpose in the first sentence. The 'Args' and 'Returns' sections are structured clearly without unnecessary details, making it efficient and easy to parse. Every sentence adds value, with no wasted words.

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

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

Given the tool's low complexity (1 parameter) and the presence of an output schema (which handles return values), the description is mostly complete. It covers the purpose and parameter semantics adequately. However, it lacks behavioral details like authentication or error handling, which are important for a tool with no annotations, preventing a perfect score.

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

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

The description adds meaning beyond the input schema by explaining that 'project_id' is 'The ID of the project to retrieve', clarifying its purpose. With schema description coverage at 0% and 1 parameter, this compensates well, providing essential context that the schema alone lacks. However, it doesn't detail format constraints or examples, keeping it from a perfect 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 verb ('Get') and resource ('a single project by ID'), making the purpose specific and understandable. It distinguishes from sibling 'todoist_get_projects' by specifying 'single project' versus multiple projects. However, it doesn't explicitly contrast with other siblings like 'todoist_get_task', leaving minor room for improvement.

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 by stating 'Get a single project by ID', suggesting it's for retrieving specific projects when the ID is known. It doesn't provide explicit when-to-use guidance versus alternatives like 'todoist_get_projects' for listing all projects or 'todoist_get_task' for tasks, nor does it mention prerequisites or exclusions, leaving usage context partially inferred.

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 the tool returns 'a formatted string' but doesn't describe what that formatting includes, whether there's pagination, rate limits, authentication requirements, or error conditions. For a read operation with zero annotation coverage, this leaves significant behavioral 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 appropriately brief with two sentences that directly address purpose and return value. It's front-loaded with the core functionality and avoids unnecessary elaboration, though the 'Returns:' formatting could be slightly more integrated.

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, read-only operation) and the presence of an output schema, the description covers the basic purpose adequately. However, for a tool with no annotations, it should provide more behavioral context about authentication, rate limits, or what 'formatted string' means to be fully complete.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the empty parameter set. The description appropriately doesn't add parameter information beyond what the schema provides, maintaining a clean baseline for parameterless 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 verb 'Get' and resource 'list of all projects from Todoist', making the purpose immediately understandable. It distinguishes from siblings like todoist_get_project (singular) by specifying 'all projects', but doesn't explicitly contrast with other list tools like todoist_get_tasks.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention when this tool is appropriate versus todoist_get_project (for a specific project) or todoist_get_tasks (for tasks), nor does it discuss prerequisites or context for usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that it 'Get[s] a single task by ID' and returns 'A formatted string containing the task details,' which covers basic read-only behavior. However, it lacks details on error handling, permissions, rate limits, or other behavioral traits, making it insufficient for a tool with no annotation support.

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 ('Get a single task by ID.'), followed by brief sections for Args and Returns. Every sentence earns its place without redundancy, making it highly efficient.

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

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

Given the tool's low complexity (1 parameter, no annotations, but has an output schema), the description is complete enough for basic use. It covers the purpose, parameter semantics, and return format. The output schema existence means the description doesn't need to detail return values, so it adequately addresses the context without being overly verbose.

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

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

The description adds meaning by specifying that 'task_id' is 'The ID of the task to retrieve,' which clarifies its purpose beyond the schema's type definition (string). With 0% schema description coverage and 1 parameter, this compensates adequately, but it doesn't provide additional context like format or constraints, so it meets the baseline for minimal parameter info.

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 ('Get') and resource ('a single task by ID'), making it immediately understandable. However, it doesn't explicitly distinguish this from sibling tools like 'todoist_get_tasks' (plural) beyond the singular/plural difference, which is why it doesn't reach a perfect 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 implies usage by stating it retrieves a task by ID, suggesting it's for when you have a specific task identifier. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'todoist_get_tasks' for multiple tasks or other sibling tools, leaving some ambiguity.

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 that it returns 'a formatted string containing the list of tasks,' which adds some behavioral context beyond the basic 'get' operation. However, it doesn't disclose critical details like whether this is a read-only operation (implied but not stated), pagination behavior, rate limits, authentication needs, or error handling, leaving significant gaps 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 appropriately sized and front-loaded, starting with a clear purpose statement followed by structured sections for Args and Returns. Every sentence earns its place by providing essential information without redundancy, making it 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 tool's moderate complexity (2 optional parameters) and the presence of an output schema (which handles return values), the description is somewhat complete but has gaps. It covers purpose and parameters well, but without annotations, it lacks behavioral transparency (e.g., safety, limits). The output schema reduces the need to explain returns, but overall completeness is adequate with clear room for improvement.

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

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

With 0% schema description coverage, the description must compensate, and it does by explaining both parameters: 'project_id' as 'Optional project ID to filter tasks by project' and 'filter_string' as 'Optional filter/query string (e.g., "today", "overdue", "#work").' This adds meaningful semantics beyond the schema, including examples for filter_string, though it could provide more detail on format 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 ('Get') and resource ('list of tasks from Todoist'), making the purpose evident. It distinguishes this from sibling tools like todoist_get_task (singular) and todoist_get_projects, but doesn't explicitly contrast with other read operations beyond the optional filters mentioned.

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

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

The description implies usage through 'optional filters' but doesn't explicitly state when to use this tool versus alternatives like todoist_get_task (for a single task) or todoist_get_projects. It provides some context for filtering but lacks clear guidance on exclusions or prerequisites.

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 the tool updates a project but doesn't mention permission requirements, whether changes are reversible, rate limits, or what happens to unspecified fields. The return statement is vague ('confirmation message'), lacking detail on success/error responses.

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 with a clear opening sentence followed by well-organized 'Args' and 'Returns' sections. Every sentence adds value without redundancy, making it easy to scan and understand 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 4 parameters with 0% schema coverage and no annotations, the description does a decent job explaining parameters but lacks behavioral context (e.g., auth needs, error handling). The output schema exists, so return value details aren't needed, but overall completeness is only adequate 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?

Schema description coverage is 0%, so the description must compensate. It clearly explains all 4 parameters (project_id, name, color, is_favorite) and their optionality, adding meaningful context beyond the bare schema. However, it doesn't specify valid color formats or favorite flag implications, leaving minor gaps.

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

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

The description clearly states the verb ('Update') and resource ('existing project in Todoist'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'todoist_update_task' beyond the resource name, which prevents a perfect 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 like 'todoist_add_project' for creation or 'todoist_delete_project' for removal. It also doesn't mention prerequisites (e.g., needing an existing project ID) or contextual constraints, leaving usage decisions ambiguous.

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 the tool updates tasks and returns a confirmation message, but lacks critical details: whether this requires authentication, what happens if optional fields are omitted (partial updates vs. overwrites), error conditions, or rate limits. For a mutation tool with zero annotation coverage, this is insufficient.

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, starting with the core purpose. The 'Args' and 'Returns' sections are structured clearly, though the formatting could be more concise (e.g., bullet points instead of full sentences for parameters). Every sentence adds value, 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?

Given the tool's complexity (mutation with 6 parameters), lack of annotations, and presence of an output schema (implied by 'Returns'), the description is moderately complete. It covers parameters well but misses behavioral context like error handling or auth requirements. The output schema likely details the confirmation message, reducing the need for return value explanation.

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 significant value beyond the input schema, which has 0% description coverage. It explains each parameter's purpose (e.g., 'task_id: The ID of the task to update', 'priority: Optional new priority (1-4)'), clarifying semantics that aren't evident from schema types alone. This compensates well for the schema's lack of 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 verb ('Update') and resource ('an existing task in Todoist'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from its sibling 'todoist_update_project', which updates projects rather than tasks, though this distinction is somewhat implied by the name and context.

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 'todoist_complete_task' or 'todoist_delete_task', nor does it mention prerequisites (e.g., needing an existing task ID). It simply states what the tool does without contextual usage information.

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