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

The description adds valuable behavioral context beyond what annotations provide: it explains how recurring tasks behave (advances to next occurrence), clarifies the semantic difference between 'completing' and 'deleting' tasks, and mentions the tool's purpose as the 'standard way' to check off tasks. While annotations cover idempotency and non-destructive nature, the description enhances understanding of the operation's effects.

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

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

The description is perfectly structured with three focused sentences: the core purpose, behavioral nuance about recurring tasks, and explicit alternative. Every sentence earns its place with no wasted words. The information is front-loaded with the main purpose stated first.

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

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

For a single-parameter mutation tool with good annotations but no output schema, the description provides excellent context about the operation's behavior, sibling differentiation, and usage guidance. The main gap is the lack of information about return values or error conditions, but given the tool's relative simplicity and clear annotations, the description is nearly complete.

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

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

With 100% schema description coverage, the schema already fully documents the single parameter (task_id). The description doesn't add any additional parameter semantics beyond what's in the schema, so it meets the baseline expectation without providing extra value. The description focuses on tool behavior 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 specific action ('Mark a Todoist task as completed'), identifies the resource ('task'), and distinguishes it from sibling tools by explaining it's the standard way to check off tasks versus permanent deletion. The verb+resource combination is precise and unambiguous.

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

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

The description provides explicit guidance on when to use this tool ('standard way to check off a task'), when not to use it ('For recurring tasks...advances to the next occurrence rather than permanently removing it'), and names a specific alternative ('Use todoist_delete_task to permanently remove a task instead'). This gives clear context for 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=true. The description adds useful context about the return value ('Returns the created label's ID and name') and practical usage guidance about label name vs ID. However, it doesn't disclose additional behavioral traits like rate limits, authentication requirements, or what happens on duplicate label names.

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

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

The description is perfectly front-loaded with the core purpose in the first sentence, followed by return value information and practical usage guidance. Every sentence earns its place with zero waste or redundancy. The two sentences are precisely what's needed for this 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?

For a creation tool with good annotations (readOnlyHint=false, destructiveHint=false) but no output schema, the description provides adequate context by specifying the return values. It could be more complete by mentioning potential error conditions or constraints (like duplicate label names), but it covers the essential information needed 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?

Schema description coverage is 100%, so the schema already fully documents all 4 parameters. The description doesn't add any parameter-specific information beyond what's in the schema. With complete schema coverage, the baseline score of 3 is appropriate since the description doesn't need to compensate for schema gaps.

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

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

The description clearly states the specific action ('Create a new personal label') and resource ('in Todoist'), distinguishing it from sibling tools like todoist_update_label or todoist_delete_label. It provides a complete verb+resource+scope statement that leaves no ambiguity about what this tool does.

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

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

The description provides clear context about when to use this tool by mentioning that the created label's name (not ID) should be used when assigning labels to tasks with todoist_create_task or todoist_update_task. However, it doesn't explicitly state when NOT to use it or mention alternatives like todoist_update_label for modifying existing labels.

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

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

Annotations indicate this is a write operation (readOnlyHint: false) that's non-destructive and non-idempotent. The description adds valuable context beyond annotations by specifying the return format ('full created project object including its assigned ID') and listing all color options, which helps the agent understand what to expect from the 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 perfectly structured with three focused sentences: purpose statement, color options list, and return value specification. Every sentence serves a clear purpose with zero wasted words, and the color list is presented efficiently in a comma-separated format.

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 good annotations and comprehensive schema coverage, the description provides adequate context. It covers the essential behavioral aspects (what gets created and returned) and parameter guidance (color options). The main gap is lack of explicit usage guidelines versus sibling tools, but overall it's reasonably complete for this complexity level.

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

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

With 100% schema description coverage, the input schema already documents all 5 parameters thoroughly. The description adds marginal value by providing the complete color list (which the schema references) and mentioning the return object, but doesn't significantly enhance parameter understanding beyond what's already in the structured schema.

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

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

The description clearly states the specific action ('Create a new project') and resource ('in Todoist'), distinguishing it from sibling tools like todoist_update_project or todoist_delete_project. It provides a complete verb+resource combination that leaves no ambiguity about the tool's function.

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

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

The description implies usage context through the color list and return value mention, but doesn't explicitly state when to use this tool versus alternatives like todoist_update_project for modifications. No explicit guidance on prerequisites, error conditions, or comparison with sibling tools 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?

Annotations already indicate this is a non-destructive, non-idempotent write operation (readOnlyHint: false, destructiveHint: false, idempotentHint: false). The description adds value by specifying the return format ('Returns the created section's ID and details'), which isn't covered by annotations. However, it doesn't mention potential constraints like rate limits or authentication requirements.

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

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

The description is efficiently structured in two sentences: the first states the core purpose, and the second provides usage context and return value information. Every sentence adds value without redundancy, making it appropriately sized and front-loaded.

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

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

Given the tool's moderate complexity (creation operation with 3 parameters) and lack of output schema, the description does a good job by explaining the return value and linking to sibling tools. However, it could benefit from mentioning potential errors or prerequisites (e.g., valid project_id).

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 each parameter clearly documented in the schema itself. The description doesn't add any additional meaning or clarification about the parameters beyond what the schema provides, so it meets the baseline score of 3 for high schema coverage.

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

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

The description clearly states the specific action ('Create a new section') and resource ('within a Todoist project'), distinguishing it from sibling tools like todoist_create_project or todoist_create_task. It precisely defines what the tool does without being vague or tautological.

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

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

The description provides clear context by mentioning that the created section ID can be used with todoist_create_task, but it doesn't explicitly state when to use this tool versus alternatives like todoist_update_section or todoist_get_sections. It offers some guidance but lacks explicit when/when-not comparisons.

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

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

Annotations already indicate this is a write operation (readOnlyHint=false) that's non-destructive and non-idempotent. The description adds valuable context beyond annotations by specifying the return format ('full created task object including its assigned ID') and clarifying natural language date handling and priority defaults, which are behavioral traits not captured in 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 perfectly structured: first sentence states the core purpose, followed by focused paragraphs explaining key parameters and return value. Every sentence adds value with zero wasted words, and it's appropriately sized for a 10-parameter 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?

For a creation tool with no output schema, the description provides good coverage of key behavioral aspects (return format, natural language date handling, priority mapping). It could be more complete by mentioning authentication requirements or error conditions, but given the annotations and schema coverage, it's mostly adequate.

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

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

With 100% schema description coverage, the baseline is 3. The description adds meaningful semantic context for due_string (natural language examples), priority (mapping of values to labels), and clarifies the return value, providing value beyond the schema's technical descriptions.

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

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

The description clearly states the specific action ('Create a new task') and resource ('in Todoist'), distinguishing it from sibling tools like todoist_update_task or todoist_delete_task. It's not a tautology and provides clear 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 implies usage context through parameter explanations (e.g., due_string supports natural language, priority defaults), but doesn't explicitly state when to use this tool versus alternatives like todoist_update_task or todoist_complete_task. No explicit when-not-to-use 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?

The description adds significant behavioral context beyond annotations: it specifies the permanent nature of deletion ('cannot be undone') and the cascading effect ('removed from all tasks'). While annotations indicate destructiveHint=true, the description provides concrete details about what destruction entails, enhancing transparency.

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

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

The description is extremely concise with just two sentences that each serve a clear purpose: the first states the action and resource, the second explains consequences. There's no wasted language, and critical information is front-loaded appropriately.

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

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

For a destructive operation with good annotations but no output schema, the description provides essential context about permanence and cascading effects. It could potentially mention authentication requirements or error conditions, but it covers the most critical behavioral aspects adequately.

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

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

With 100% schema description coverage, the input schema already fully documents the label_id parameter. The description doesn't add any additional parameter information beyond what's in the schema, so it meets the baseline expectation without providing extra semantic value.

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

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

The description clearly states the specific action ('permanently delete') and resource ('personal Todoist label'), distinguishing it from sibling tools like todoist_update_label and todoist_get_labels. It precisely communicates the tool's function without ambiguity.

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

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

The description implies usage context by stating the label will be removed from all tasks, suggesting it should be used when wanting to completely eliminate a label. However, it doesn't explicitly state when to use this versus alternatives like todoist_update_label or provide clear exclusions.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, but the description adds valuable context: it specifies that deletion is permanent and irreversible, and that all tasks within the project are also deleted. This goes beyond annotations by detailing the scope and consequences, though it doesn't cover other behavioral aspects like rate limits or auth needs.

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 only two sentences, both of which are essential: the first states the action and irreversibility, and the second reinforces the cascading deletion. There is no wasted text, and it is front-loaded with the core warning.

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

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

Given the tool's destructive nature and lack of output schema, the description is reasonably complete by emphasizing permanence and cascading effects. However, it could be more comprehensive by mentioning potential error conditions or confirmation steps, though annotations cover some behavioral aspects.

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

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

The input schema has 100% description coverage, with the project_id parameter clearly documented. The description does not add any additional meaning or details about the parameter beyond what the schema provides, so it meets the baseline for high schema coverage without compensation.

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 explicitly states the action ('Permanently delete') and resource ('a Todoist project and all its tasks'), making the purpose clear. It distinguishes from siblings like todoist_delete_task by specifying it deletes the entire project with all tasks, not just individual tasks or other 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 clear context with warnings about permanent deletion and cascading effects on tasks, which helps determine when to use this tool. However, it does not explicitly mention alternatives (e.g., using todoist_update_project to archive instead) or when-not-to-use scenarios beyond the warning, so it's not fully 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?

The description adds valuable behavioral context beyond annotations: it clarifies that tasks are not deleted but moved to the parent project, the deletion is permanent and cannot be undone, and the section is removed. Annotations already indicate destructiveHint=true, but the description elaborates on the specific consequences, enhancing transparency.

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

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

The description is front-loaded with the main action and resource, followed by critical behavioral details in two concise sentences. Every sentence adds essential information without redundancy, making it efficient and well-structured.

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

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

Given the tool's complexity (destructive operation with one parameter) and rich annotations (e.g., destructiveHint=true), the description is complete. It explains the key behavioral outcomes (task movement, permanence) and purpose, compensating for the lack of an output schema by clarifying what happens post-deletion.

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

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

The input schema has 100% description coverage, with the parameter 'section_id' fully documented. The description does not add any additional meaning or context about the parameter beyond what the schema provides, such as format examples or constraints, so it meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('permanently delete') and resource ('Todoist section'), distinguishing it from siblings like todoist_delete_project or todoist_delete_task. It precisely identifies what is being deleted, avoiding ambiguity.

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

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

The description implies usage by specifying that tasks are moved to the parent project, suggesting this tool is for removing sections while preserving tasks. However, it does not explicitly state when to use this versus alternatives like todoist_update_section or provide exclusions, such as if the section must be empty.

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

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

The description adds valuable behavioral context beyond annotations: 'This action cannot be undone' clarifies the permanence of deletion, which complements the destructiveHint annotation. However, it doesn't mention other behavioral aspects like error conditions or what happens to subtasks. No contradiction with annotations exists.

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

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

The description is perfectly concise with two sentences that each serve a distinct purpose: the first states the core action with critical warning, the second provides essential usage guidance. No wasted words or redundant information.

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

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

For a destructive operation with good annotations and a simple parameter schema, the description provides sufficient context about permanence and alternatives. However, without an output schema, it could benefit from mentioning what the tool returns (e.g., success confirmation or error).

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

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

With 100% schema description coverage, the input schema already fully documents the single required parameter. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets but doesn't exceed the baseline expectation.

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

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

The description clearly states the specific action ('permanently delete') and resource ('Todoist task'), distinguishing it from sibling tools like todoist_complete_task. It uses precise language that leaves no ambiguity about what the tool does.

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

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

The description explicitly provides when-not-to-use guidance ('For recurring tasks or tasks you just want to mark as done, use todoist_complete_task instead'), naming a specific alternative. This gives clear context for choosing between deletion and completion 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, covering safety and idempotency. The description adds value by specifying the return format ('Returns label IDs, names, colors, and sort order') and a usage tip about names vs. IDs, but does not disclose additional behavioral traits like rate limits or authentication needs.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by return details and a usage tip in two concise sentences. Every sentence adds value without redundancy, making it efficient and well-structured.

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

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

Given the tool's low complexity (1 optional parameter, no output schema) and rich annotations, the description is mostly complete. It covers purpose, return values, and a usage tip, but could improve by mentioning sibling alternatives or behavioral details like pagination, though not strictly necessary here.

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

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

Schema description coverage is 100%, with the parameter 'response_format' fully documented in the schema. The description does not add any parameter-specific information beyond what the schema provides, so it meets the baseline of 3 for high schema coverage.

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

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

The description clearly states the verb ('List') and resource ('all personal labels in the user's Todoist account'), distinguishing it from siblings like todoist_create_label or todoist_update_label. It specifies 'personal labels' to indicate scope, which is more precise than just '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 clear context for usage by stating 'Use label names (not IDs) when creating or updating tasks,' which implicitly guides when to use this tool (to get names for other operations). However, it does not explicitly mention when not to use it or name alternatives among siblings.

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

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

Annotations already indicate read-only, non-destructive, idempotent, and open-world behavior. The description adds value by specifying the return format details ('full project details including name, color, parent project, comment count, sharing status, and view style'), which provides useful context beyond annotations. No contradiction with annotations exists.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by a concise list of return details. Both sentences are essential, with no wasted words, making it efficient and easy to parse.

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

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

Given the tool's low complexity (2 parameters, 100% schema coverage, no output schema), the description is mostly complete. It clearly states the purpose and return details, but could improve by explicitly mentioning when to use versus sibling tools. The annotations provide strong behavioral context, compensating for minor gaps.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters. The description does not add any additional meaning beyond the schema, such as explaining the format of 'project_id' or elaborating on 'response_format' options. Baseline score of 3 is appropriate as the schema adequately documents parameters.

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

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

The description clearly states the specific action ('Retrieve a single Todoist project') and resource ('by its ID'), distinguishing it from sibling tools like 'todoist_get_projects' (plural) which retrieves multiple projects. The verb 'retrieve' is precise and unambiguous.

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

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

The description implies usage context by specifying 'by its ID' and listing the returned details, which helps differentiate it from 'todoist_get_projects'. However, it does not explicitly state when to use this tool versus alternatives like 'todoist_get_projects' or 'todoist_get_task', nor does it mention prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, covering safety and idempotency. The description adds valuable context about what data is returned (IDs, names, colors, hierarchy, favorite/shared metadata) and the connection to todoist_get_tasks, which goes beyond annotations. No contradictions with annotations.

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

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

Three sentences, each earning its place: first states purpose, second details return data, third provides usage guidance. No wasted words, front-loaded with core functionality. Efficiently structured for agent 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 read-only list tool with comprehensive annotations (readOnly, non-destructive, idempotent, openWorld) and 100% schema coverage, the description provides complete context: what it does, what data it returns, and how to use the output. No output schema exists, but the description adequately describes return values.

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 a single parameter 'response_format' fully documented in the schema. The description doesn't mention parameters at all, which is acceptable given the high schema coverage. Baseline 3 is appropriate when the schema does all the parameter documentation work.

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

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

The description clearly states the verb 'List' and resource 'all projects in the user's Todoist account', providing specific scope. It distinguishes from sibling tools like todoist_get_project (singular) by emphasizing 'all projects' and mentions hierarchy details not implied by the name/title alone.

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?

Explicit guidance is provided: 'Use project IDs with todoist_get_tasks to fetch tasks for a specific project.' This tells the agent when to use this tool (to get project IDs for later task fetching) and references a specific alternative sibling tool, though it doesn't explicitly say when NOT to use it.

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

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

The description adds valuable context beyond annotations by specifying what data is returned ('section IDs, names, and sort order') and how to use the output with other tools. Annotations already cover read-only, non-destructive, idempotent, and open-world hints, so the bar is lower, but the description enhances understanding of the tool's behavior in the broader workflow.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by clarifying context and usage guidance. Each sentence adds value without redundancy, making it efficient and well-structured for quick comprehension by an AI agent.

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 (simple list operation), rich annotations (covering safety and behavior), and 100% schema coverage, the description is largely complete. It explains the purpose, usage, and output context. The lack of an output schema is mitigated by the description specifying what data is returned, though more detail on output structure could slightly improve completeness.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (project_id and response_format). The description does not add any additional parameter details beyond what the schema provides, such as format specifics or examples. This meets the baseline of 3 when the schema handles parameter documentation effectively.

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

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

The description clearly states the verb ('List') and resource ('sections within a Todoist project'), and distinguishes it from siblings by specifying it's for retrieving sections rather than tasks, projects, or labels. It explicitly mentions what sections are used for, which helps differentiate from other list operations like todoist_get_tasks.

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

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

The description provides explicit guidance on when to use this tool by stating it's for listing sections within a project, and it names specific alternatives (todoist_get_tasks and todoist_create_task) for working with tasks in those sections. This clearly delineates its role versus other sibling tools.

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

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

Annotations already cover read-only, non-destructive, idempotent, and open-world hints. The description adds value by specifying the return format options (markdown/json) and listing the detailed fields included in the response, which provides useful context beyond the annotations. No contradictions with annotations are present.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by a concise list of return details. Both sentences earn their place by providing essential information without redundancy, making it efficient and well-structured.

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

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

Given the tool's low complexity, rich annotations, and 100% schema coverage, the description is mostly complete. It lacks an output schema but compensates by detailing return fields. However, it could slightly improve by mentioning error handling or prerequisites, though not critical for this simple retrieval tool.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters. The description does not add significant meaning beyond the schema, as it only mentions the task_id parameter implicitly ('by its ID') and does not elaborate on response_format beyond what the schema provides. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the specific action ('retrieve a single Todoist task') and resource ('by its ID'), distinguishing it from sibling tools like todoist_get_tasks (plural) and todoist_get_project. It precisely defines what the tool does without being vague or tautological.

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

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

The description implies usage context ('by its ID') for retrieving a specific task, but does not explicitly state when to use this versus alternatives like todoist_get_tasks for multiple tasks or todoist_get_project for project details. It provides clear intent but lacks explicit comparison or exclusion guidance.

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

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

The description adds valuable behavioral context beyond what annotations provide. While annotations indicate read-only, non-destructive, idempotent, and open-world characteristics, the description clarifies that the tool returns paginated results (via 'cursor' parameter), supports output format selection (markdown vs. json), and provides concrete examples of filter syntax and combinations. This enhances the agent's understanding of how to effectively use the 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 well-structured and appropriately sized. It starts with a clear purpose statement, then provides detailed usage guidelines with bullet-point examples, followed by alternative filtering methods and return value information. Every sentence adds value, with no redundant or unnecessary information, making it efficient for the agent to parse.

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

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

Given the tool's complexity (7 parameters, no output schema) and rich annotations, the description is complete enough. It covers purpose, usage guidelines, parameter semantics with examples, and return value details. The absence of an output schema is compensated by describing what the tool returns (task IDs, content, due dates, etc.), ensuring the agent has sufficient context 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 description adds significant meaning beyond the input schema. Although schema description coverage is 100%, the description provides practical examples and explanations for the 'filter' parameter (e.g., 'today', 'overdue', combining with & and |), which helps the agent understand how to construct effective filter strings. This goes beyond the schema's generic description of 'Todoist filter string.'

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

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

The description clearly states the tool's purpose as 'List and filter tasks from Todoist,' which is a specific verb+resource combination. It distinguishes itself from siblings like todoist_get_task (singular) by emphasizing listing and filtering multiple tasks, and from todoist_get_projects/todoist_get_sections by focusing on tasks rather than other entities.

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 explicit guidance on when to use this tool versus alternatives. It explains that the 'filter' parameter supports natural-language Todoist filters with examples, and mentions alternative filtering methods via project_id, section_id, or label directly. This helps the agent choose between using the powerful filter syntax or more direct parameter-based filtering.

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

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

Annotations cover key behavioral traits (mutable, non-destructive, idempotent, open-world), so the bar is lower. The description adds useful context about the 'previously completed' precondition and practical scenarios, but doesn't mention rate limits, auth needs, or error conditions. No contradiction with annotations exists.

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?

Two concise sentences: the first states the purpose, the second provides usage guidance. Every word earns its place with zero waste, and information is front-loaded appropriately 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 simple mutation tool with good annotations (covering safety and idempotency) and full schema coverage, the description is largely complete. It lacks output details (no output schema provided) and doesn't cover edge cases like invalid IDs, but the core purpose and usage are well-defined given the context.

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

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

Schema description coverage is 100%, with the single parameter 'task_id' well-documented in the schema as 'ID of the completed task to reopen'. The description doesn't add further parameter details beyond implying the task must be completed, which aligns with the schema. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('reopen (uncomplete)') and resource ('a previously completed Todoist task'), distinguishing it from siblings like 'todoist_complete_task' and 'todoist_update_task'. It precisely defines the operation without ambiguity.

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?

It explicitly provides when-to-use guidance: 'Useful for tasks that were marked done by mistake or need to be revisited.' This directly addresses the primary use case and implicitly distinguishes it from alternatives like creating new tasks or updating existing ones.

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

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

Annotations already cover key traits (mutable, non-destructive, idempotent, open-world), so the bar is lower. The description adds valuable context with 'Only include fields to change,' clarifying partial update behavior, which isn't captured in annotations. No contradictions with annotations.

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

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

The description is a single, efficient sentence that front-loads the core purpose and includes a crucial behavioral note. Every word earns its place with no redundancy or fluff.

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

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

For a mutation tool with rich annotations (covering safety, idempotency) and full schema coverage, the description is adequate but lacks output details (no schema provided) and doesn't fully address sibling differentiation. It meets minimum viability given the structured data support.

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%, providing full parameter documentation. The description adds minimal value beyond the schema by implying partial updates but doesn't explain parameter interactions or constraints like color format. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('Update') and resource ('existing Todoist label'), distinguishing it from creation and deletion operations. However, it doesn't explicitly differentiate from other update tools like todoist_update_project or todoist_update_task, which would require mentioning it's specifically for 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 implicit guidance with 'Only include fields to change,' suggesting partial updates. However, it lacks explicit when-to-use criteria, such as when to choose this over todoist_create_label or todoist_delete_label, or prerequisites like needing the label_id.

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

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

Annotations cover key behavioral traits (readOnlyHint=false, destructiveHint=false, idempotentHint=true, openWorldHint=true), so the description's burden is lower. It adds value by specifying 'Only include fields to change,' which clarifies partial update behavior, but doesn't elaborate on permissions, rate limits, or error handling. No contradiction with annotations exists.

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

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

The description is a single, efficient sentence that front-loads the core action ('Update an existing Todoist project') and adds a crucial constraint ('Only include fields to change') without any wasted words. Every part of the sentence serves a clear purpose.

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

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

Given the tool's moderate complexity (update operation with 5 parameters), rich annotations (covering safety and idempotency), and 100% schema coverage, the description is reasonably complete. It lacks output schema information, but the description's focus on input behavior is adequate for the context provided by structured fields.

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 each parameter well-documented in the schema. The description adds minimal value beyond the schema by implying partial updates ('Only include fields to change'), but doesn't provide additional syntax, format details, or examples. This meets the baseline of 3 for high schema coverage.

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

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

The description clearly states the verb ('Update') and resource ('existing Todoist project'), making the purpose immediately understandable. It distinguishes from creation tools like 'todoist_create_project' by specifying 'existing', but doesn't explicitly differentiate from other update tools like 'todoist_update_task' or 'todoist_update_label'.

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 guidance with 'Only include fields to change,' suggesting partial updates are supported. However, it doesn't explicitly state when to use this tool versus alternatives like 'todoist_update_task' or 'todoist_update_label,' nor does it mention prerequisites or exclusions beyond what's implied.

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

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

Annotations cover key behavioral traits (mutable, non-destructive, idempotent, open-world), so the bar is lower. The description adds minimal context by specifying 'Rename' as the action, which implies a specific type of update, but doesn't elaborate on side effects, error conditions, or response format. It doesn't contradict 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, direct sentence with zero waste—'Rename an existing Todoist section.' It's front-loaded and appropriately sized for a simple update operation, earning its place by clearly stating the core action.

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

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

Given the tool's moderate complexity (a mutation with two parameters), annotations provide good coverage, but there's no output schema. The description is minimal and doesn't address return values or error handling. It's adequate as a basic descriptor but lacks depth for full agent understanding 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?

Schema description coverage is 100%, with clear descriptions for both parameters (section_id and name). The description adds no additional meaning beyond the schema, such as explaining name constraints (e.g., character limits) or how to obtain section_id. Baseline 3 is appropriate when the schema fully documents 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 ('Rename') and resource ('an existing Todoist section'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from sibling update tools like todoist_update_label or todoist_update_project, which follow the same pattern but for 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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid section_id), compare it to other update tools for different resources, or indicate when not to use it (e.g., for creating new sections vs. renaming existing ones).

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

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

The description adds valuable behavioral context beyond what annotations provide: it explains the partial update pattern ('Only include the fields you want to change'), clarifies edge cases for due dates (empty string vs null behavior), and specifies that labels array replaces all existing labels. Annotations already indicate this is a non-destructive, idempotent, open-world mutation, but the description provides concrete implementation details that help the agent understand how to use the tool correctly.

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

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

The description is perfectly structured and concise: it starts with the core purpose, then provides critical usage guidelines, followed by specific behavioral notes. Every sentence earns its place by addressing important aspects of tool usage. The information is front-loaded with the most important guidance first, and there's no wasted verbiage.

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 10 parameters and no output schema, the description does an excellent job covering the essential context. It explains the partial update pattern, clarifies edge cases, and provides important behavioral details. The main gap is the lack of information about what the tool returns (no output schema), but given the annotations indicate it's an open-world mutation, the description provides sufficient guidance 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?

With 100% schema description coverage, the baseline is 3, but the description adds significant value by clarifying parameter interactions and special cases: it explains the partial update approach, details how to clear due dates using clear_due_date, warns about due_string vs due_date behavior, and explains priority mapping. It also clarifies that labels array replaces all existing labels, which isn't obvious from the schema alone.

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

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

The description clearly states the verb 'Update' and resource 'existing Todoist task', making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like todoist_update_project or todoist_update_section, which have similar update patterns but different resources. The description is specific about what gets updated but doesn't contrast with similar update operations.

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

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

The description provides clear context about when to use this tool ('Update an existing Todoist task') and includes important usage notes about partial updates and special cases for clearing due dates and labels. However, it doesn't explicitly mention when NOT to use it (e.g., vs todoist_complete_task for marking tasks done) or name specific alternatives for different scenarios, though the sibling tool names provide some implicit guidance.

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