todoist-mcp

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 'close tasks' which implies a mutation (changing task status), but doesn't explain what 'close' means operationally (e.g., marks as complete vs archives), whether it's reversible (hinting at 'reopen_tasks' sibling), or any side effects. This leaves significant behavioral 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 extremely concise with just two sentences that directly address core functionality and parameter identification. Every word earns its place with zero redundancy or fluff, making it efficiently front-loaded 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?

For a mutation tool with no annotations, 0% schema coverage, and no output schema, the description is insufficient. It doesn't explain what 'close' means in Todoist context, whether multiple tasks can be closed, what happens on success/failure, or how this differs from deletion. The agent lacks critical context to use this tool effectively.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that either 'task_id' or 'task_name' can identify targets, which adds meaningful context beyond the bare schema. However, it doesn't clarify the 'items' array structure, whether both fields can be used together, or how name matching works, leaving some parameter semantics unclear.

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 ('close tasks') and target system ('Todoist'), which is specific and unambiguous. However, it doesn't differentiate this tool from its sibling 'reopen_tasks' or other task-related tools, missing an opportunity to clarify its unique role in the toolset.

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., tasks must exist), exclusions, or compare it to sibling tools like 'delete_tasks' or 'reopen_tasks', leaving the agent without contextual usage cues.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Create new comments' implies a write operation, the description doesn't address important behavioral aspects: whether this requires specific permissions, what happens when creating multiple comments, whether there are rate limits, what the response format looks like, or how errors are handled. 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 maximally concise - a single sentence with no wasted words. It's front-loaded with the essential action and target system. Every word earns its place, though this conciseness comes at the expense of completeness.

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

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

Given this is a mutation tool with no annotations, no output schema, and complex nested parameters (items array with objects), the description is severely incomplete. It doesn't address the behavioral implications of creating comments, doesn't explain the parameter structure, and provides no context about the Todoist comment system. For a tool that creates data in a task management system, this leaves too many unknowns for effective agent use.

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

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

The schema has 0% description coverage, so the description must compensate but provides no parameter information. The schema shows a complex 'items' array with nested objects containing 'task_id', 'project_id', and 'content' fields, but the description doesn't explain what these mean, their relationships, or usage patterns. The description adds zero value beyond what's visible in the bare schema structure.

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

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

The description clearly states the action ('Create new comments') and the target system ('in Todoist'), which provides a specific verb+resource combination. However, it doesn't distinguish this tool from its sibling 'update_comments' or explain how it differs from 'get_comments' - it only establishes basic purpose without sibling differentiation.

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

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

The description provides no guidance about when to use this tool versus alternatives like 'update_comments' or 'delete_comments'. There's no mention of prerequisites, appropriate contexts, or when this tool should be preferred over other comment-related operations. The agent receives no usage direction beyond the basic purpose statement.

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 'Create' which implies a write/mutation operation, but doesn't disclose any behavioral traits: no information about permissions required, whether creation is idempotent, rate limits, error conditions, or what happens on success (e.g., returns label IDs). 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 a single, efficient sentence that gets straight to the point without unnecessary words. It's appropriately sized for a basic tool description, though it could benefit from additional context. Every word earns its place, but the brevity comes at the cost of completeness.

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

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

Given this is a mutation tool with no annotations, 0% schema description coverage, and no output schema, the description is incomplete. It doesn't explain what the tool returns, error conditions, authentication requirements, or how it interacts with the Todoist system. The agent lacks crucial information needed to use this tool effectively in production scenarios.

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 for undocumented parameters. The description mentions 'personal labels' but doesn't explain the 'items' array parameter or its nested properties (name, order, color, is_favorite). While it implies batch creation through 'labels' plural, it provides no semantic context about parameter usage, constraints, or relationships between fields.

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

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

The description clearly states the action ('Create') and resource ('new personal labels in Todoist'), making the purpose immediately understandable. It distinguishes from sibling tools like 'update_labels' and 'delete_labels' by specifying creation rather than modification or deletion. However, it doesn't explicitly differentiate from 'create_projects' or 'create_tasks' beyond the resource type.

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 (like authentication needs), when not to use it, or how it differs from related tools like 'create_shared_labels' (which doesn't exist but might be relevant given 'get_shared_labels' and 'remove_shared_labels' siblings). The agent must infer usage from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions creation but fails to specify whether this requires authentication, what happens on success/failure, if there are rate limits, or how errors are handled. This leaves significant gaps for a mutation tool.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

For a creation tool with no annotations, no output schema, and 0% schema description coverage, the description is inadequate. It doesn't explain parameters, behavioral traits, or expected outcomes, leaving the agent with insufficient information to use the tool effectively.

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

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

The schema description coverage is 0%, but the description doesn't compensate by explaining the 'items' parameter or its nested properties (name, parent_id, color, etc.). However, since there's only one parameter, the baseline is 4, but the lack of any parameter explanation reduces it to 3, as the description adds no value beyond 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 action ('Create') and resource ('new projects in Todoist'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'create_tasks' or 'create_sections' beyond specifying the resource type, 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 'create_tasks' or 'create_sections', nor does it mention any prerequisites or constraints. It simply states what the tool does without context for 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 full burden for behavioral disclosure. It states this is a creation operation, implying mutation, but doesn't address permissions, rate limits, error conditions, or what happens on success (e.g., whether it returns IDs). 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 a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place without being overly terse.

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

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

Given this is a mutation tool with no annotations, 0% schema description coverage, and no output schema, the description is incomplete. It doesn't explain what sections are, how they relate to projects/tasks, what the tool returns, or any behavioral constraints, making it inadequate for safe and effective use by an agent.

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 mentions no parameters, while the schema has 1 parameter ('items') with 0% description coverage. Since schema_description_coverage is 0%, the description should compensate but doesn't, leaving parameters undocumented. However, with only 1 parameter, the baseline is slightly higher than for multiple undocumented 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 action ('Create new sections') and resource ('in Todoist'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'create_projects' or 'create_tasks', which would require more specificity about what sections are in Todoist's hierarchy.

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 'create_projects' or 'create_tasks'. It doesn't mention prerequisites (e.g., needing an existing project), exclusions, or typical use cases, leaving the agent to infer context from sibling tool names alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a creation operation but doesn't mention authentication requirements, rate limits, whether tasks are created immediately or queued, or what happens on success/failure. 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 a single, efficient sentence with zero wasted words. It's appropriately sized for a tool with a clear primary function and gets straight to the point 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?

For a task creation tool with no annotations, no output schema, and 0% schema description coverage, the description is inadequate. It doesn't explain what parameters are needed, what the tool returns, or any behavioral aspects like permissions or side effects. The context demands more comprehensive documentation.

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

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

The schema description coverage is 0%, meaning all parameters are undocumented in the schema. The description doesn't mention any parameters at all, failing to compensate for this gap. However, the tool has only 1 top-level parameter ('items'), which is an array of task objects, making the baseline reasonable at 3 despite the lack of parameter explanation.

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

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

The description clearly states the action ('Create new tasks') and target system ('in Todoist'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'create_projects' or 'create_labels' beyond the resource type, 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 'update_tasks' or 'create_projects', nor does it mention prerequisites, constraints, or appropriate contexts for task creation. It's a bare statement of functionality.

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 ('Delete') which implies a destructive mutation, but doesn't specify permissions required, whether deletion is permanent/reversible, rate limits, or what happens on success/failure. This leaves significant gaps for a destructive operation.

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

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

The description is extremely concise at just three words, with zero wasted text. It's front-loaded with the essential action and resource. Every word earns its place, though this conciseness comes at the cost of completeness.

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

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

For a destructive mutation tool with no annotations, 0% schema description coverage, and no output schema, the description is inadequate. It doesn't explain what 'comments' are in Todoist context, doesn't cover parameters or return values, and provides minimal behavioral context. The tool needs more explanation given its complexity and potential impact.

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 but provides no parameter information. The schema shows one parameter 'items' (an array of objects with 'id'), but the description doesn't explain what 'items' represents, what 'id' refers to, or format requirements. This leaves parameters largely undocumented.

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 ('comments in Todoist'), making the purpose immediately understandable. It distinguishes from sibling tools like 'create_comments' and 'update_comments' by specifying deletion, though it doesn't explicitly differentiate from other deletion tools like 'delete_labels' or 'delete_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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing comment IDs), exclusions, or comparisons to siblings like 'delete_tasks' or 'update_comments'. Usage is implied by the name but not explicitly stated.

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 deletes personal labels and identifies targets via 'id' or 'name', but fails to disclose critical traits: whether deletion is permanent/reversible, if it affects associated tasks, required permissions, rate limits, or error handling. For a destructive operation, 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 with two sentences that are front-loaded and waste no words. Every part contributes directly to understanding the tool's purpose and identification method, 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 destructive nature, lack of annotations, 0% schema coverage, and no output schema, the description is incomplete. It doesn't cover behavioral aspects (permanence, side effects), parameter details beyond basic identification, or return values, leaving the agent with inadequate context for safe and effective use.

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

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

Schema description coverage is 0%, so the description must compensate. It adds minimal semantics by mentioning 'id' or 'name' to identify targets, but doesn't explain the 'items' array structure, that multiple labels can be deleted at once, or the preference for 'id' over 'name' (implied but not explicit). This is insufficient for a 1-parameter tool with complex nested objects.

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 personal label in Todoist'), which is specific and unambiguous. It distinguishes the tool by specifying it's for personal labels (not shared labels), though it doesn't explicitly differentiate from sibling tools like 'delete_tasks' or 'delete_projects' beyond the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'update_labels' or 'delete_shared_labels', nor does it mention prerequisites (e.g., needing label existence or permissions). It only states how to identify the target, not when this operation is appropriate.

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

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

No annotations are provided, so the description carries full burden. It states 'Delete' which implies a destructive mutation, but doesn't disclose critical behaviors: whether deletion is permanent/reversible, authentication requirements, rate limits, error handling, or what happens to associated data (e.g., tasks in deleted projects). This leaves significant gaps for safe agent operation.

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 brief and front-loaded with the core action. Both sentences are necessary: the first states the purpose, the second explains parameter usage. No wasted words, though it could be more structured (e.g., bullet points for behaviors).

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

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

For a destructive mutation tool with no annotations, 0% schema coverage, and no output schema, the description is incomplete. It lacks behavioral context (permanence, side effects), error information, and output expectations. Given the complexity and risk of deletion, this is inadequate for safe agent invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that either 'id' or 'name' can identify targets, and implies 'id' is preferred, adding meaningful semantics beyond the bare schema. However, it doesn't clarify the 'items' array structure or constraints (e.g., bulk deletion limits).

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 ('Delete') and resource ('projects from Todoist'), making the purpose unambiguous. It distinguishes from siblings like 'delete_tasks' or 'delete_comments' by specifying the resource type. However, it doesn't explicitly differentiate from 'move_projects' or 'update_projects' in terms of destructive nature.

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 'move_projects' or 'update_projects', nor does it mention prerequisites (e.g., authentication needs) or consequences. It only explains parameter identification, not contextual 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a deletion operation (implying destructive mutation) but doesn't mention critical aspects like whether deletions are permanent, require specific permissions, have rate limits, or what happens to associated tasks. For a destructive tool 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 extremely concise at just two sentences, with zero wasted words. The first sentence states the core purpose, and the second provides essential parameter guidance. Every sentence earns its place, making it efficiently front-loaded 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?

For a destructive mutation tool with no annotations, no output schema, and minimal parameter documentation, the description is insufficiently complete. It doesn't address behavioral consequences, error conditions, authentication requirements, or what the tool returns. Given the complexity of a deletion operation and the lack of structured documentation, the description should provide more contextual information.

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 semantic context by explaining that either 'id' or 'name' can identify targets, with 'id' being preferred. However, with 0% schema description coverage and 1 parameter (an array of objects with id/name properties), the description doesn't explain the array structure, whether multiple sections can be deleted at once, or how name matching works. It provides basic guidance but doesn't fully compensate 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 action ('Delete') and resource ('sections in Todoist'), making the purpose immediately understandable. It distinguishes itself from sibling tools like 'delete_projects' or 'delete_tasks' by specifying sections. However, it doesn't explicitly mention whether this deletes single or multiple sections, which would make it 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing project context), consequences (e.g., tasks in deleted sections), or when to choose between 'delete_sections' and other deletion tools like 'delete_projects' or 'delete_tasks'. The only usage hint is about parameter identification, which is more about parameters than 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 full burden for behavioral disclosure. It states this is a deletion operation (implying destructive mutation) but doesn't mention whether deletions are permanent, reversible, require specific permissions, or have rate limits. The description lacks critical behavioral context like confirmation prompts, side effects, or error handling for a destructive operation.

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 core functionality. The first sentence establishes purpose, the second clarifies parameter usage. There's no redundant information or unnecessary elaboration. However, the structure could be slightly improved by front-loading critical behavioral warnings for a destructive operation.

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

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

For a destructive mutation tool with no annotations, 0% schema description coverage, and no output schema, the description is insufficient. It doesn't explain what happens after deletion (success confirmation, error responses), whether deletions cascade to related data, or important constraints. The description leaves too many behavioral and operational questions unanswered given the tool's complexity and risk profile.

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 mentions 'task_id' or 'task_name' as identification methods, which partially explains the nested object structure. However, it doesn't clarify that these are properties within an array of items, nor does it explain whether both fields can be used together, if one is preferred, or what happens with ambiguous names. The description adds minimal value beyond the bare 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 action ('Delete') and resource ('tasks from Todoist'), making the purpose immediately understandable. It distinguishes itself from siblings like 'close_tasks' or 'reopen_tasks' by specifying permanent deletion rather than state changes. However, it doesn't explicitly differentiate from 'delete_projects' or 'delete_sections' beyond the resource type.

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 'close_tasks' (which might archive instead of delete) or 'reopen_tasks'. It mentions identification methods ('task_id' or 'task_name') but doesn't explain prerequisites, error conditions, or when deletion is appropriate versus other operations. No explicit when/when-not statements are 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 states the action ('Get all collaborators') but lacks details on permissions required, rate limits, pagination, error handling, or output format. This is inadequate for a tool with zero annotation coverage, as it leaves critical behavioral traits unspecified.

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 with zero waste. It is front-loaded with the core purpose and appropriately sized for the tool's complexity, making it easy to parse quickly.

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

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

Given the lack of annotations, no output schema, and incomplete parameter documentation (0% coverage), the description is insufficient. It states what the tool does but omits critical context such as return values, error conditions, and behavioral constraints, making it incomplete for effective agent use.

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

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

The description does not mention the 'id' parameter at all, and with 0% schema description coverage, the parameter is undocumented in both the schema and description. However, since there is only one parameter, the baseline is 4, but the description fails to add any semantic value (e.g., explaining that 'id' refers to a project ID), so it is penalized to a score of 3 for not compensating for the 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 ('Get') and resource ('all collaborators for a project in Todoist'), making the purpose unambiguous. However, it does not explicitly differentiate from sibling tools like 'get_projects' or 'get_tasks', which target different resources but share the 'get' pattern, so it falls short of 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. It does not mention prerequisites (e.g., needing a valid project ID), exclusions, or comparisons to sibling tools like 'get_projects_list' or 'get_tasks_list' for related data, leaving usage context implied at best.

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 it 'gets' comments (implying read-only), but doesn't specify authentication requirements, rate limits, error conditions, or what happens with invalid IDs. For a tool with one required parameter and no 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 extremely concise at just 5 words with zero wasted language. It's front-loaded with the core action and resource. While under-specified, every word contributes directly to the tool's purpose 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 1 parameter with 0% schema coverage, no annotations, no output schema, and multiple sibling tools including 'get_comments_list', the description is incomplete. It doesn't explain the parameter's format, differentiate from alternatives, describe return values, or address behavioral aspects like error handling. The minimal description is inadequate for this 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 0%, so the description must compensate but doesn't. The single parameter 'items' (an array of objects with 'id') is undocumented in both schema and description. The description mentions 'by ID' which hints at the parameter purpose but doesn't explain format, constraints, or that multiple IDs can be provided via an array.

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 states the action ('Get') and resource ('comments from Todoist'), but is vague about scope and mechanism. It doesn't specify whether this retrieves comments for single or multiple items, or how it differs from sibling 'get_comments_list' which suggests a list operation. The purpose is understandable but lacks differentiation from alternatives.

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 like 'get_comments_list' or 'get_tasks' (which might include comments). The description doesn't mention prerequisites, context, or exclusions, leaving the agent to infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden. It states 'Get comments list' which implies a read-only operation, but doesn't disclose behavioral traits like authentication needs, rate limits, pagination, or what happens if no filters are applied (e.g., returns all comments). This leaves gaps for safe agent invocation.

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 with zero waste—'Get comments list from Todoist' is front-loaded and appropriately sized for a simple tool. Every word earns its place 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 no annotations, no output schema, and a read operation with filtering parameters, the description is incomplete. It lacks details on return format (e.g., list structure, fields), error handling, or prerequisites (e.g., authentication). For a tool with 2 parameters and behavioral uncertainty, this is inadequate.

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

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

Schema description coverage is 100%, with clear descriptions for 'project_id' and 'task_id' as filters. The description adds no parameter semantics beyond the schema, but since coverage is high, the baseline is 3. It doesn't explain how filters interact (e.g., combined or exclusive) or default behaviors.

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 'Get comments list from Todoist' clearly states the action (get) and resource (comments list), but it's vague about scope and doesn't distinguish from sibling tools like 'get_comments' (singular vs. list). It specifies the source (Todoist) but lacks detail on what 'list' entails (e.g., all comments, filtered).

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 on when to use this tool versus alternatives like 'get_comments' (singular) or other filtering tools. The description implies it retrieves comments, but doesn't specify contexts (e.g., for reporting, review) or exclusions (e.g., not for editing).

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 but offers minimal information. It doesn't mention whether this is a read-only operation, how results are returned (e.g., pagination details beyond schema), authentication requirements, rate limits, or error conditions. The phrase 'filtering options' hints at functionality but lacks behavioral specifics.

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 ('Get completed tasks from Todoist'). It avoids redundancy and wastes no words, though it could be slightly more structured by explicitly mentioning key filtering capabilities.

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 tool with 8 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain return values, error handling, or behavioral nuances like pagination behavior (implied by offset/limit but not described). The agent would need to rely heavily on the schema alone, missing contextual guidance.

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

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

The schema description coverage is 100%, with all 8 parameters well-documented in the schema itself. The description adds no additional parameter semantics beyond mentioning 'filtering options', which is already covered by the schema. This meets the baseline of 3 when schema coverage is high.

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

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

The description clearly states the action ('Get completed tasks') and resource ('from Todoist'), making the purpose immediately understandable. It distinguishes itself from siblings like 'get_tasks' by specifying 'completed' tasks, though it doesn't explicitly contrast with other filtering tools like 'get_tasks_list'.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_tasks' or 'get_tasks_list'. It mentions 'filtering options' but doesn't specify when this tool is preferred over other task-retrieval methods, leaving the agent to infer usage 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?

No annotations are provided, so the description carries the full burden. It implies a read operation ('Get') but doesn't disclose behavioral traits such as authentication needs, rate limits, error handling, or what happens if multiple labels match. The description is minimal and leaves critical behavioral aspects unspecified.

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 very concise with two sentences, front-loading the purpose. There's no wasted text, but it may be overly brief, risking under-specification. Every sentence adds value, though more detail could improve clarity without sacrificing 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 no annotations, 0% schema coverage, no output schema, and a parameter count of 1 with nested objects, the description is incomplete. It doesn't explain the return format, error conditions, or how the tool interacts with sibling tools like 'get_labels_list'. For a tool with minimal structured data, more context is needed.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions using 'id' or 'name' to identify the target, which adds some meaning beyond the schema's property names. However, it doesn't explain the 'items' array structure, clarify if both 'id' and 'name' can be used together, or provide examples. With 1 parameter and low coverage, this is insufficient.

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 states the tool 'Get a personal label from Todoist', which provides a clear verb ('Get') and resource ('personal label'), distinguishing it from sibling tools like 'get_labels_list' or 'get_shared_labels'. However, it lacks specificity about what 'get' entails (e.g., retrieve details, fetch metadata) and doesn't fully differentiate from similar tools beyond mentioning 'personal'.

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 'get_labels_list' or 'get_shared_labels'. It mentions identifying a target with 'id' or 'name', but this is parameter guidance rather than usage context. No exclusions, prerequisites, or comparative advice are given.

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 retrieves data ('Get'), implying a read-only operation, but doesn't specify aspects like authentication needs, rate limits, or what 'personal labels' entails (e.g., scope, format). This leaves significant gaps for a tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without any redundant words. It is front-loaded and appropriately sized for a simple retrieval tool.

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 (0 parameters, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks details on behavior, output format, and differentiation from siblings, making it incomplete for optimal agent use 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?

The tool has 0 parameters, and the schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate, but it could have clarified the absence of filters (e.g., no user ID parameter). Baseline is 4 for zero 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 action ('Get') and resource ('all personal labels from Todoist'), making the purpose unambiguous. However, it doesn't distinguish this tool from sibling tools like 'get_labels' or 'get_shared_labels', which appear to have similar functions, so it falls short of 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 such as 'get_labels' or 'get_shared_labels'. It lacks any mention of prerequisites, context, or exclusions, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries full burden. It mentions the tool retrieves projects but doesn't disclose behavioral traits like whether it's read-only, what permissions are needed, error conditions, or response format. 'Get' implies read operation but lacks confirmation of safety or other behavioral 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?

The description is appropriately concise with two sentences that directly address the tool's purpose and parameter usage. No wasted words, though it could be slightly more structured with clearer separation of purpose versus parameter guidance.

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 no annotations, 0% schema coverage, no output schema, and a retrieval tool with 1 parameter (though complex nested structure), the description is incomplete. It doesn't explain the array-based input format, what happens when multiple projects are requested, error handling, or return format, leaving significant gaps for agent understanding.

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 adds value by explaining that either 'id' or 'name' can identify targets and that 'id' is preferred, which clarifies the parameter semantics beyond the bare schema. However, it doesn't fully explain the array structure or that 'items' contains objects with these properties.

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 'projects from Todoist', making the purpose understandable. It doesn't explicitly distinguish from sibling 'get_projects_list', but the parameter structure suggests this retrieves specific projects rather than listing all projects.

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 minimal guidance about parameter usage ('Either id or name'), but offers no context about when to use this tool versus alternatives like 'get_projects_list' or other retrieval tools. No explicit when/when-not guidance is provided.

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

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

With no annotations provided, the description carries full burden but only states the basic action without disclosing behavioral traits. It doesn't mention whether this is a read-only operation, if it requires authentication, rate limits, pagination, or what the return format looks like, which is inadequate for a tool with zero annotation coverage.

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

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

The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, directly stating the tool's purpose 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 complexity (a list retrieval tool), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'all projects' entails (e.g., scope, filtering, or return structure), leaving significant gaps for the agent to understand the tool's behavior and output.

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 fully documents the input. The description doesn't need to add parameter details, and it appropriately doesn't mention any. A baseline of 4 is applied since no parameters exist, and the description doesn't introduce confusion.

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

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

The description clearly states the action ('Get all projects') and resource ('from Todoist'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'get_projects' (singular vs. list distinction isn't explained), so it doesn't reach the highest score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_projects' or other list-retrieval tools. There's no mention of context, prerequisites, or exclusions, leaving the agent with minimal usage direction.

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 'id' is preferred over 'name', which adds some context, but it doesn't cover critical aspects like whether this is a read-only operation, potential rate limits, authentication needs, or what the return format looks like. For a retrieval 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 brief and to the point with two sentences, avoiding unnecessary verbosity. It front-loads the core purpose and provides essential parameter guidance efficiently, though it could be slightly more structured for clarity.

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 retrieval tool with no annotations, 0% schema description coverage, and no output schema, the description is incomplete. It lacks details on behavior, return values, error handling, and differentiation from siblings, making it inadequate for full contextual understanding.

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 for undocumented parameters. It adds some meaning by explaining that 'id' or 'name' can identify targets and that 'id' is preferred, but it doesn't fully clarify the structure of the 'items' array or how multiple sections are handled. With 1 parameter and low coverage, this is a moderate 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 action ('Get') and resource ('sections from Todoist'), making the purpose understandable. However, it doesn't distinguish this tool from sibling tools like 'get_sections_list' or 'get_projects', which suggests it might retrieve specific sections rather than listing all sections.

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 minimal guidance by mentioning that either 'id' or 'name' can be used to identify targets, but it doesn't specify when to use this tool versus alternatives like 'get_sections_list' or other retrieval tools. No explicit when/when-not scenarios or prerequisites are included.

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 but only states the action without details on permissions, rate limits, response format, or error handling. For a read operation tool, this leaves significant gaps in understanding how it behaves in practice.

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, direct sentence with no wasted words, making it highly concise and front-loaded. It efficiently communicates the core purpose 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 complexity (a read operation with one parameter), lack of annotations, no output schema, and minimal description, it's incomplete. The description doesn't cover parameter usage, return values, or behavioral traits, making it inadequate for full contextual understanding.

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 one parameter ('project_id') with 0% description coverage, and the tool description adds no information about this parameter's purpose, format, or usage. This fails to compensate for the schema's lack of documentation, leaving the parameter's semantics unclear.

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

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

The description clearly states the action ('Get') and resource ('sections list from Todoist'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_sections' or 'get_projects_list', which would require more specificity to earn 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 'get_sections' or 'get_projects_list', nor does it mention prerequisites or context for usage. It's a basic statement of function without operational 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 full burden for behavioral disclosure but only states what the tool does, not how it behaves. It doesn't mention whether this is a read-only operation, if it requires authentication, what format the output takes, or any rate limits or constraints. For a 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 a single, efficient sentence that communicates the essential purpose without any wasted words. It's appropriately sized for a simple retrieval tool and front-loads the key 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 lack of annotations and output schema, the description should provide more context about the tool's behavior, output format, and differentiation from similar tools. As a read operation among many Todoist tools, the minimal description leaves significant gaps in understanding how to properly use this 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 tool has zero parameters with 100% schema description coverage, so the schema already fully documents the parameter situation. The description appropriately doesn't discuss parameters, maintaining focus on the tool's purpose. Baseline for zero parameters is 4.

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

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

The description clearly states the action ('Get all') and resource ('shared labels from Todoist'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_labels' or 'get_labels_list', which could cause confusion about when to use each tool.

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 'get_labels' or 'get_labels_list'. There's no mention of prerequisites, context, or comparison with sibling tools, leaving the agent to guess about appropriate usage 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?

With no annotations provided, the description carries full burden but offers limited behavioral insight. It mentions that task_id is 'preferred' (implied from schema) but doesn't disclose whether this is a read-only operation, what happens if multiple tasks match, error conditions, or response format. For a retrieval 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 brief and front-loaded with the core purpose. Both sentences are relevant, though the second sentence could be more structured. There's no wasted text, but it borders on being too terse given 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?

For a tool with 1 parameter (a complex array structure), 0% schema description coverage, no annotations, and no output schema, the description is inadequate. It doesn't explain what 'Get tasks' returns, how to interpret the items array, error handling, or how this differs from similar retrieval tools in the sibling set.

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 but only partially does. It mentions 'task_id' and 'task_name' as identification methods, but doesn't explain the 'items' array structure, that both fields are optional within items, or the implications of using name versus ID. The description adds some meaning but doesn't fully address the undocumented parameter complexity.

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

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

The description clearly states the action ('Get tasks') and resource ('from Todoist'), making the purpose understandable. It distinguishes from siblings like 'get_tasks_list' by implying retrieval of specific tasks rather than listing all tasks. However, it doesn't explicitly contrast with other get_* tools like 'get_completed_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?

The description provides minimal guidance by mentioning two ways to identify tasks (task_id or task_name), but offers no explicit advice on when to use this tool versus alternatives like 'get_tasks_list' or 'get_completed_tasks'. No context about prerequisites, limitations, or typical use cases is provided.

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 but only states the basic action. It doesn't mention whether this is a read-only operation, what permissions are required, how results are returned (pagination, format), rate limits, or any other behavioral characteristics beyond the minimal 'get' operation.

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

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

The description is extremely concise at just 5 words, front-loading the essential information with zero wasted words. It efficiently communicates the core purpose 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?

For a tool with 6 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what kind of list is returned, how results are structured, whether there's pagination, or any behavioral context. The minimal description fails to compensate for the 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?

With 83% schema description coverage, the schema already documents most parameters well, especially the 'filter' parameter with extensive examples. The description adds no parameter information beyond what's in the schema, so it meets the baseline expectation but doesn't enhance understanding of parameter usage or interactions.

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

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

The description clearly states the action ('Get') and resource ('tasks list from Todoist'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'get_tasks' or 'get_completed_tasks', which would require more specific scope information.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'get_tasks' and 'get_completed_tasks' available, there's no indication of how this list retrieval differs from those other retrieval operations or when one should be preferred over another.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action is a move but doesn't clarify if this is a destructive operation (e.g., overwriting existing parent relationships), what permissions are required, how errors are handled, or the response format. 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 action ('Move a projects') and destination. There is no wasted wording, making it highly concise and well-structured for quick understanding.

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, 0% schema description coverage, and no output schema, the description is incomplete. It fails to address critical aspects like behavioral traits (e.g., idempotency, error handling), parameter meanings, or return values, leaving the agent with insufficient context for reliable use.

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

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

Schema description coverage is 0%, so the description must compensate, but it only mentions moving projects without detailing parameters. The input schema defines an 'items' array with id, name, and parent_id, but the description adds no semantic context about these fields, such as that parent_id can be null for root-level moves. Baseline 3 is given as it minimally addresses the tool's purpose without parameter specifics.

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 ('Move') and resource ('projects'), specifying the destination ('to a different parent in Todoist'). It distinguishes from sibling tools like move_tasks by focusing on projects rather than tasks, though it doesn't explicitly contrast with them.

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 like update_projects or create_projects for restructuring projects. The description lacks context about prerequisites, such as needing existing projects and parent IDs, or when moving is appropriate versus deletion/recreation.

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 moves tasks, implying a mutation operation, but doesn't cover critical aspects like required permissions, whether the move is reversible, potential side effects (e.g., impact on task dependencies), 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 extremely concise—just two sentences—with zero wasted words. It front-loads the core purpose and follows with a critical constraint, making it easy to parse 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 the complexity of a mutation tool with no annotations, 0% schema description coverage, and no output schema, the description is incomplete. It lacks information on behavioral traits (e.g., permissions, side effects), detailed parameter usage, and expected outcomes, which are essential for safe and effective tool invocation.

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

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

The description adds crucial semantic information beyond the input schema: it clarifies that exactly one of parent_id, section_id, or project_id must be provided, which isn't evident from the schema alone. With 0% schema description coverage and 1 parameter (a nested array), this compensation is valuable, though it doesn't fully explain the 'items' array structure or individual field purposes.

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 ('Move tasks') and target ('to a different parent or section in Todoist'), which is specific and unambiguous. However, it doesn't explicitly differentiate from siblings like 'move_projects' or 'update_tasks' which might handle similar operations on different resources.

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 implicit usage guidance by specifying that exactly one of parent_id, section_id, or project_id must be provided, which helps understand when to use this tool. However, it doesn't explicitly mention when to choose this tool over alternatives like 'update_tasks' or 'move_projects', nor does it provide 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 but offers minimal behavioral insight. 'Remove' implies a destructive mutation, but there's no information about permissions required, whether removal is permanent/reversible, rate limits, or what happens to tasks using these labels. The description doesn't compensate for the lack of 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 a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a simple operation and front-loads the essential information.

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

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

For a destructive mutation tool with no annotations, 0% schema coverage, and no output schema, the description is inadequate. It doesn't explain what 'remove' entails operationally, what parameters are needed, what the response looks like, or error conditions. The agent lacks sufficient context 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 and 1 parameter ('items'), the description provides no parameter information. It doesn't explain that 'items' is an array of objects with 'name' properties, what format labels should be in, or whether multiple labels can be removed at once. The description fails to compensate 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 action ('Remove') and target resource ('a shared label in Todoist'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'delete_labels' or 'rename_shared_labels' - the agent must infer that this specifically handles shared labels versus regular labels.

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 like 'delete_labels' or 'rename_shared_labels'. The description doesn't mention prerequisites (e.g., needing existing shared labels), exclusions, or appropriate contexts for this operation.

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 ('Rename') but doesn't describe what happens during the rename (e.g., whether it affects existing tasks with the label, permission requirements, rate limits, or error conditions). For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding the tool's 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, with zero wasted information.

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

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

For a mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is inadequate. It doesn't explain the batch nature of the operation (implied by 'items' array), what the tool returns, error handling, or how it differs from similar tools like 'update_labels'. The context signals indicate complexity that isn't addressed.

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 doesn't mention parameters at all, while the input schema has 1 parameter ('items') with 0% description coverage. Since schema_description_coverage is 0%, the description fails to compensate by explaining the parameter structure. However, the tool name 'rename_shared_labels' (plural) hints at batch operations, which aligns with the array parameter, providing minimal context beyond 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 action ('Rename') and resource ('shared label in Todoist'), making the purpose immediately understandable. It distinguishes from sibling tools like 'update_labels' by specifying 'shared label' rather than general label updates, though it doesn't explicitly contrast with 'remove_shared_labels'.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'update_labels' or 'remove_shared_labels'. It doesn't mention prerequisites, constraints, or typical scenarios for renaming shared labels versus other label operations.

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

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

With no annotations provided, the description carries full burden but offers limited behavioral insight. It implies a mutation operation ('Reopen') but doesn't disclose permissions needed, whether changes are reversible, rate limits, error conditions, or what happens if tasks are already open. The description adds minimal context beyond the basic action.

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

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

The description is brief and front-loaded with the core purpose. Both sentences are relevant, with the second clarifying identification options. There's no redundant information, though it could be more structured (e.g., separating purpose from parameter guidance).

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, 0% schema coverage, and no output schema, the description is insufficient. It lacks details on behavioral traits, error handling, return values, and comprehensive parameter usage. Given the complexity of reopening tasks (which may involve state transitions), more context is needed for effective tool invocation.

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

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

Schema description coverage is 0%, so the description must compensate but provides incomplete parameter guidance. It mentions 'task_id' or 'task_name' as identification methods, but doesn't explain the 'items' array structure, whether both fields can be used together, or if multiple tasks can be reopened at once. The description adds some meaning but leaves key parameter semantics unclear.

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 ('Reopen') and resource ('tasks in Todoist'), making the purpose unambiguous. It distinguishes from siblings like 'close_tasks' by specifying the opposite operation. However, it doesn't explicitly mention what 'reopen' means in this context (e.g., marking incomplete tasks from a completed state).

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 minimal guidance by mentioning two identification methods ('task_id' or 'task_name'), but offers no context on when to use this tool versus alternatives. It doesn't specify prerequisites (e.g., tasks must be closed), compare with similar tools like 'update_tasks', or indicate typical scenarios for reopening 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?

With no annotations provided, the description carries full burden but offers minimal behavioral insight. 'Update' implies a mutation operation, but it doesn't disclose permissions needed, rate limits, whether updates are atomic or batched, error handling, or what happens on success/failure. For a tool with 1 parameter (an array of items), this lack of context 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 a single, front-loaded sentence with no wasted words. It efficiently conveys the core purpose without redundancy or unnecessary elaboration. Every word earns its place, making it easy for an agent to parse quickly.

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

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

Given no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't address behavioral aspects (e.g., mutation effects), parameter meanings, or return values. For a tool that updates multiple comments via an array, more context is needed to guide proper invocation.

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

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

Schema description coverage is 0%, so the description must compensate but adds no parameter information. It doesn't explain the 'items' array structure, the 'id' field (e.g., comment ID), or 'content' field (e.g., updated text). The baseline is 3 because the schema itself defines the parameters clearly (type, required fields), but the description provides zero additional semantic context.

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

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

The description clearly states the action ('Update') and resource ('comments in Todoist'), making the purpose immediately understandable. It distinguishes from siblings like 'create_comments' and 'delete_comments' by specifying modification rather than creation or deletion. However, it doesn't specify what aspects of comments are updated (e.g., content, metadata), 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. It doesn't mention prerequisites (e.g., existing comments), exclusions (e.g., cannot update deleted comments), or comparisons to sibling tools like 'create_comments' for new comments or 'delete_comments' for removal. The agent must infer usage from the name alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is an update operation, implying mutation, but doesn't mention permission requirements, whether changes are reversible, rate limits, or what happens to unspecified fields. For a mutation tool 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 a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly.

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

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

For a mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't explain what 'update' entails, what the input structure is, or what to expect upon success/failure. Given the complexity implied by the nested parameter schema, more context is needed for effective use.

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

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

Schema description coverage is 0%, so the description must compensate, but it provides no parameter information. The schema shows a single 'items' parameter with nested properties for updating label attributes, yet the description doesn't mention this structure or what fields can be modified. Baseline is 3 since the schema fully defines parameters, but the description adds no value beyond 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 action ('Update') and resource ('a personal label in Todoist'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'create_labels' or 'delete_labels' beyond the verb, nor does it specify what aspects of a label can be updated.

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 like 'create_labels' or 'delete_labels'. The description doesn't mention prerequisites (e.g., needing an existing label ID) or contextual constraints, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Update' implies mutation, the description doesn't disclose important behavioral traits like whether this requires specific permissions, what happens when multiple fields are updated simultaneously, whether changes are reversible, or if there are rate limits. It mentions identification via 'id' or 'name' but doesn't explain the implications of choosing one over the other beyond 'id' being 'preferred'.

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 concise with just two sentences that get straight to the point. The first sentence establishes the core purpose, and the second provides key usage information. There's no wasted language or unnecessary elaboration, though it could be slightly more structured by explicitly separating purpose from parameter guidance.

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, 0% schema description coverage, and no output schema, the description is incomplete. It doesn't explain what fields can be updated beyond the identification parameters, doesn't describe the expected response format, and doesn't address error conditions or prerequisites. Given the complexity of updating multiple projects with various fields, the description provides insufficient context for effective tool use.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. The description only mentions 'id' and 'name' as identification parameters, completely ignoring the other three parameters (color, is_favorite, view_style) that are present in the schema. This leaves most parameters undocumented and their purposes unclear.

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 'projects in Todoist', making the purpose immediately understandable. It distinguishes from siblings like 'create_projects' and 'delete_projects' by specifying this is for updating existing projects rather than creating new ones or deleting them. However, it doesn't fully differentiate from 'move_projects' which also modifies projects.

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 some usage guidance by stating 'Either 'id' or the 'name' to identify the target', which helps understand how to select which project to update. However, it doesn't explicitly state when to use this tool versus alternatives like 'move_projects' or when not to use it (e.g., for creating new projects). The guidance is implied rather than explicit.

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 states 'Update' which implies mutation, but doesn't disclose behavioral traits such as required permissions, whether updates are reversible, rate limits, or what happens on success/failure. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, clear sentence with no wasted words. It's front-loaded and efficiently conveys the core action and resource, making it appropriately concise and well-structured.

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

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

Given the complexity of a mutation tool with no annotations, 0% schema description coverage, and no output schema, the description is incomplete. It lacks details on parameters, behavior, error handling, and output, leaving significant gaps for the agent to understand and use the tool effectively.

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

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

The description provides no parameter information, and schema description coverage is 0%. The input schema defines an 'items' array with 'id' and 'name' properties, but the description doesn't explain what these represent (e.g., that 'id' identifies sections to update and 'name' sets new names). This fails to compensate for the lack of 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 states the action ('Update') and resource ('sections in Todoist'), which provides a basic understanding of what the tool does. However, it doesn't specify what aspects of sections can be updated or how this differs from sibling tools like 'create_sections' or 'delete_sections', making it somewhat vague.

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?

There is no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., existing sections to update), contrast with 'create_sections' for new sections, or specify scenarios where updates are appropriate, leaving the agent without usage 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool 'Update tasks' which implies a mutation operation, but it fails to describe critical behaviors such as authentication requirements, rate limits, error handling, or what happens if multiple tasks are updated. The description adds minimal context beyond the name, leaving significant gaps in understanding how the tool behaves in practice.

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 brief with two sentences, making it efficient and front-loaded. However, it could be more structured by explicitly separating identification from update capabilities. While concise, it risks under-specification given the tool's complexity, but 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 complexity of the tool with 1 parameter (an array of objects with multiple sub-properties), no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It lacks details on behavioral traits, parameter meanings beyond identification, and expected outcomes, making it inadequate for a mutation tool with rich input options.

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

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

The schema description coverage is 0%, meaning parameters are undocumented in the schema, and the description only addresses identification ('task_id' or 'task_name') without explaining the 'items' array structure or the many other parameters like 'content', 'priority', or 'due_date'. This leaves most parameters unexplained, and the description does not compensate for the low coverage, providing insufficient semantic context for effective use.

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 states 'Update tasks in Todoist' which provides a clear verb ('Update') and resource ('tasks in Todoist'), making the basic purpose understandable. However, it doesn't differentiate this tool from sibling tools like 'update_projects' or 'update_sections' beyond the resource type, nor does it specify what aspects of tasks can be updated beyond the identification method 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 provides minimal guidance by stating 'Either 'task_id' or the 'task_name' to identify the target,' which hints at how to use the tool for identification but offers no broader context. It doesn't explain when to use this tool versus alternatives like 'create_tasks' or 'delete_tasks,' nor does it mention prerequisites or exclusions, leaving usage unclear beyond basic identification.

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 'Get' implies a read-only operation, it doesn't specify whether this requires authentication, has rate limits, returns cached vs. live data, or what format the colors are returned in (hex codes, names, etc.). The description provides minimal behavioral context beyond the basic operation.

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

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

The description is a single, efficient sentence that communicates the essential purpose without any wasted words. It's appropriately sized for a simple, parameterless tool and is front-loaded with the core functionality.

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

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

For a simple read-only tool with no parameters and no output schema, the description is minimally adequate. However, it doesn't explain what the return value contains (just colors? with IDs? metadata?) or how the colors relate to the mentioned resources. Given the lack of annotations and output schema, more detail about the response format 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?

With 0 parameters and 100% schema description coverage, the baseline is 4. The description appropriately doesn't waste space discussing non-existent parameters. It correctly focuses on what the tool does rather than 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 ('Get') and resource ('available colors for projects, labels, filters in Todoist'), making the purpose unambiguous. It distinguishes from siblings by focusing on color retrieval rather than task/project management operations. However, it doesn't explicitly differentiate from other 'get_' tools that might also return color information indirectly.

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 whether colors are needed for UI display, configuration purposes, or if there are other ways to obtain color information through sibling tools. No exclusions or prerequisites are stated.

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