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

With no annotations provided, the description carries full burden. It discloses that this is a creation operation (implying mutation) and mentions performance configuration options. However, it doesn't cover important behavioral aspects like error handling (beyond the optional 'continueOnError' in schema), rate limits, authentication requirements, or what happens when tasks fail partially. The description adds some context but 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 perfectly structured with bullet points, front-loading the core purpose and immediately listing requirements. Every sentence earns its place - no redundant information, no fluff. The optional performance configuration is mentioned efficiently at the end.

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

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

For a mutation tool with no annotations and no output schema, the description is adequate but incomplete. It covers the basic purpose and requirements well, but lacks information about return values, error responses, side effects, or system behavior. Given the complexity (4 parameters with nested objects) and absence of structured behavioral metadata, the description should do more to compensate.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema - it emphasizes the required array of tasks and the listId/listName choice, but doesn't provide additional semantic context about parameter interactions or usage patterns that aren't already in the schema descriptions.

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

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

The description clearly states the verb 'Create multiple tasks' and specifies the resource 'in a list efficiently', distinguishing it from sibling tools like 'create_task' (singular) and 'create_list' (different resource). It explicitly mentions bulk creation, which sets it apart from single-task 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 for when to use this tool (creating multiple tasks efficiently) and mentions required inputs (array of tasks, listId or listName). However, it doesn't explicitly state when NOT to use it or name specific alternatives like 'create_task' for single tasks, which would be helpful for sibling differentiation.

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

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

With no annotations provided, the description carries the full burden. It discloses that this is a creation/mutation operation and mentions the post-creation workflow, but lacks details about permissions, error conditions, rate limits, or what happens if the folder name already exists. It adds some context but not comprehensive behavioral traits.

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

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

The description is efficiently structured with two sentences: one stating the purpose and requirements, and another providing usage guidance. Every sentence adds value, with no redundant information. It's appropriately sized and front-loaded with essential information.

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

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

For a mutation tool with no annotations and no output schema, the description does an adequate job explaining the basic operation and workflow. However, it lacks information about return values, error handling, and specific behavioral constraints that would be important for a creation tool. It's minimally viable but has clear gaps.

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

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

Schema description coverage is 100%, so the schema already documents all 4 parameters thoroughly. The description adds minimal value by listing required parameters and preferences (spaceId preferred over spaceName), but doesn't provide additional semantic context beyond what's in the schema. 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 ('Create a new folder') and resource ('in a ClickUp space'), distinguishing it from siblings like 'create_list' or 'update_folder'. It explicitly mentions the purpose ('for organizing related lists'), which differentiates it from other creation tools.

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

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

The description provides explicit guidance on when to use this tool: 'After creating a folder, you can add lists to it using create_list_in_folder.' It also specifies parameter preferences: 'Either spaceId (preferred) or spaceName', giving clear alternatives for context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates something new (implying a write/mutation operation) and specifies the location constraint ('directly in a space'), but does not mention permissions, side effects, error conditions, or response format. This leaves 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 two sentences with zero waste: the first states the purpose and key constraint, the second provides usage guidance and alternative. It is front-loaded with essential information and appropriately sized for the tool's complexity.

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

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

For a mutation tool with no annotations and no output schema, the description adequately covers the basic purpose and sibling differentiation, but lacks details on behavioral aspects like permissions, error handling, or return values. Given the 8 parameters and write operation, more context would be beneficial, though the schema coverage helps.

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

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

Schema description coverage is 100%, so the schema fully documents all 8 parameters. The description adds minimal value beyond the schema by emphasizing the spaceId/spaceName requirement and the 'not in a folder' context, but does not provide additional syntax, format, or usage details for parameters. Baseline 3 is appropriate when 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 specific action ('Create a new list') and resource ('directly in a ClickUp space'), and explicitly distinguishes it from the sibling tool 'create_list_in_folder' by specifying 'not in a folder'. This provides precise 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?

The description provides explicit guidance on when to use this tool ('directly in a space') versus when to use an alternative ('For creating lists inside folders, use create_list_in_folder instead'). It also specifies a mandatory condition ('You MUST provide either spaceId or spaceName'), giving clear 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 the full burden of behavioral disclosure. It effectively communicates the creation operation (a write/mutation) and the parameter dependency rules, but doesn't address other behavioral aspects like authentication requirements, error conditions, rate limits, or what happens on success (e.g., returns the created list object). The description adds meaningful context about the folder name uniqueness constraint, which is valuable behavioral information.

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, followed immediately by the critical usage rules. Both sentences earn their place: the first establishes what the tool does, the second provides essential parameter guidance. There's zero wasted text, and the structure logically progresses from general to specific.

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 7 parameters, no annotations, and no output schema, the description does an excellent job covering the most critical aspects: purpose, parameter dependencies, and the uniqueness constraint rationale. However, it doesn't mention what the tool returns (output format) or potential error conditions, which would be helpful given the absence of both annotations and output schema. The parameter guidance is comprehensive, but some behavioral context is missing.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly. The description adds significant value beyond the schema by explaining the logical relationships between parameters (folderId vs folderName+space combinations) and the rationale behind them (folder name uniqueness issues). This contextual information helps the agent understand how to correctly combine parameters, elevating the score above the baseline 3.

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 list') and target resource ('within a ClickUp folder'), distinguishing it from sibling tools like 'create_list' (which presumably creates lists without folder context) and 'create_folder' (which creates folders rather than lists). 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 conditional logic for when to use different parameter combinations: 'You MUST provide either: 1) folderId alone, or 2) folderName WITH either spaceName or spaceId.' It also explains why space information is required when using folderName ('Folder names may not be unique across spaces'), offering clear guidance on parameter dependencies and alternatives.

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 effectively communicates that this is a write operation ('Create'), mentions the requirement to provide either listId or listName, and gives practical guidance about checking conversation history. However, it doesn't mention authentication requirements, rate limits, or what happens on failure, which would be valuable 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 efficiently structured with four focused sentences that each serve a distinct purpose: stating the tool's function, differentiating from siblings, providing operational guidance, and specifying parameter requirements. There is no wasted language, and the most critical information appears 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 mutation tool with no annotations and no output schema, the description does well by covering purpose, sibling differentiation, usage guidelines, and parameter relationships. However, it doesn't describe what the tool returns or potential error conditions, which would be helpful given the absence of output schema. The 100% schema coverage helps compensate for some of these 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?

With 100% schema description coverage, the baseline is 3. The description adds meaningful context beyond the schema by explaining the relationship between listId and listName parameters ('you must provide either a listId or listName'), and reinforces the guidance about using existing list IDs from conversation history. This provides valuable semantic context that complements the schema.

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

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

The description clearly states the specific action ('Create a single task'), target resource ('in a ClickUp list'), and scope ('individual task creation only'). It explicitly distinguishes this tool from its sibling 'create_bulk_tasks' by specifying the single-task use case, providing 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 provides explicit guidance on when to use this tool ('for individual task creation only') and when not to ('For multiple tasks, use create_bulk_tasks instead'). It also offers practical advice about checking conversation history for list IDs to avoid redundant lookups, giving clear 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 the full burden of behavioral disclosure. It effectively communicates critical traits: the action is permanent and irreversible, and it specifies two acceptable input patterns with safety guidance (preferring taskId). This covers key behavioral aspects like destructiveness and input constraints.

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 a warning icon and key information, followed by structured bullet points for input options. Every sentence earns its place by conveying essential warnings and usage rules without redundancy, making it highly efficient and well-organized.

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 bulk operation with no annotations or output schema), the description is largely complete: it covers purpose, behavioral risks, and parameter semantics. However, it lacks details on error handling or response format, which could be useful for a tool with such high stakes, preventing a perfect score.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the semantics of parameter options: it clarifies that taskId alone is preferred and safest, while taskName requires listName and should be used with caution. This provides practical guidance beyond the schema's structural documentation.

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

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

The description clearly states the verb ('PERMANENTLY DELETE') and resource ('multiple tasks'), distinguishing it from sibling tools like delete_task (singular) and other deletion tools. It specifies the bulk nature of the operation, making the purpose explicit and distinct.

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

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

The description provides clear context for when to use this tool (for bulk deletion of tasks) and includes cautionary notes about irreversible action. However, it does not explicitly mention when NOT to use it or name specific alternatives (e.g., delete_task for single deletions), which prevents a perfect score.

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

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

With no annotations provided, the description carries full burden and excels at disclosing critical behavioral traits. It clearly warns about permanence ('cannot be undone'), scope of deletion ('all its contents', 'all lists and tasks within the folder'), and safety considerations ('preferred and safest'). This goes well beyond what a basic 'delete' operation might imply.

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 front-loaded: it starts with the critical warning and main action, then provides parameter guidance, and ends with an additional warning about scope. Every sentence earns its place with essential information, and there's no wasted text.

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 tool with no annotations and no output schema, the description does an excellent job covering the critical aspects: permanence, scope, and parameter usage. The only minor gap is lack of explicit guidance on when to choose this tool over sibling deletion tools, but otherwise it's highly complete for its 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?

Schema description coverage is 100%, so the baseline is 3. The description adds significant value by explaining parameter combinations and their implications: it clarifies that folderId alone is 'preferred and safest' and that folderName requires space identifiers. This provides practical guidance beyond the schema's technical documentation.

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

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

The description explicitly states the action ('PERMANENTLY DELETE') and resource ('a folder and all its contents'), making the purpose crystal clear. It distinguishes itself from sibling tools like delete_list or delete_task by specifying it deletes entire folders with their contents, not just individual items.

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 guidance on when to use specific parameter combinations (folderId alone vs. folderName with space identifiers), which helps the agent choose the right approach. However, it doesn't explicitly state when to use this tool versus alternatives like delete_list or delete_task for more targeted deletions.

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 effectively communicates critical traits: the action is permanent ('Permanently delete', 'cannot be undone'), destructive (deletes list and all tasks), and has a warning about irreversibility. This adds significant value beyond what the input schema provides.

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

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

The description is front-loaded with the core action, uses only two sentences with zero waste, and includes a critical warning prominently. Every sentence earns its place by conveying essential information efficiently without redundancy.

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

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

Given the tool's destructive nature, no annotations, and no output schema, the description is mostly complete. It covers purpose, parameters, and behavioral warnings well. A minor gap is the lack of explicit mention of permissions or error cases, but it adequately addresses the core context for a deletion 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%, so the schema already documents both parameters thoroughly. The description adds marginal value by emphasizing the requirement to provide at least one parameter ('You MUST provide either listId or listName') and hinting at ambiguity with listName, but does not add new semantic details beyond the schema's 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 ('Permanently delete'), the target resource ('a ClickUp list and all its tasks'), and distinguishes it from siblings like delete_task or delete_folder by specifying it deletes an entire list with its tasks. It uses precise language that goes beyond just restating the name.

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

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

The description provides clear context on when to use it by specifying 'You MUST provide either listId or listName', which helps the agent choose between parameters. However, it does not explicitly mention when not to use it or name alternatives like delete_task for individual tasks, though the sibling list implies this distinction.

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 excels by clearly stating the tool is destructive ('PERMANENTLY DELETE'), irreversible ('cannot be undone'), and includes safety warnings ('preferred and safest', 'use with caution', 'use with extreme caution'). This covers critical behavioral traits like permanence and risk without relying on 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 highly efficient and front-loaded: it starts with a critical warning icon and key action, followed by clear parameter guidelines in a bullet-like format. Every sentence earns its place by conveying essential safety information and usage rules without redundancy, making it easy to scan and understand quickly.

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

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

Given the tool's complexity (destructive operation with 3 parameters), no annotations, and no output schema, the description is remarkably complete. It covers purpose, behavioral risks, parameter usage, and safety guidelines, leaving no critical gaps. For a deletion tool, this level of detail is sufficient to guide safe invocation without needing output schema explanations.

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 baseline is 3. The description adds significant value by explaining parameter combinations and their implications: it prioritizes 'taskId alone' as safest and warns about 'taskName' uniqueness issues, which goes beyond the schema's basic descriptions. However, it doesn't detail format constraints or edge cases, keeping it from a perfect score.

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

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

The description explicitly states the action ('PERMANENTLY DELETE') and resource ('a task'), making the purpose crystal clear. It distinguishes itself from sibling tools like 'delete_bulk_tasks' by specifying single-task deletion and from 'update_task' or 'duplicate_task' by emphasizing permanence. The use of '⚠️' and 'cannot be undone' reinforces the specific 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 explicit guidance on when to use this tool vs. alternatives through parameter combinations: it recommends 'taskId alone (preferred and safest)' and cautions about using 'taskName + optional listName (use with caution)'. This directly addresses when to choose specific parameter sets for safety, distinguishing it from bulk deletion tools like 'delete_bulk_tasks' by focusing on single-task 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 the full burden. It discloses that the duplicate preserves original properties, which is useful behavioral context. However, it doesn't cover permissions, error conditions, rate limits, or what happens to subtasks/attachments. For a mutation tool with zero annotation coverage, this leaves significant gaps in behavioral understanding.

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

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

The description is appropriately sized with three sentences. The first states the purpose, the second outlines parameter combinations, and the third adds behavioral context. It's front-loaded with the core action, though the parameter combination list could be slightly more concise.

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 and no output schema, the description should do more to explain behavioral aspects like what exactly gets copied (e.g., due dates, assignees), error scenarios, or response format. The parameter guidance is helpful, but overall completeness is adequate with clear gaps for a tool that modifies data.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds value by explaining valid parameter combinations and preferences (e.g., taskId is 'preferred'), which helps the agent choose between approaches. However, it doesn't add deep semantic context beyond what's in the schema descriptions.

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

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

The description clearly states the action ('Create a copy') and resource ('a task'), specifying it can be in the same or different list. It distinguishes from siblings like create_task by focusing on duplication rather than creation from scratch, though it doesn't explicitly name 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?

The description provides clear guidance on when to use specific parameter combinations (taskId vs taskName approaches) and indicates taskId is 'preferred.' However, it doesn't explicitly state when to use this tool versus alternatives like create_task or move_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?

No annotations are provided, so the description carries full burden. It describes the tool as a retrieval operation ('retrieve details'), which implies read-only behavior. It adds useful context about parameter combinations and the tool's purpose in understanding folder structure. However, it doesn't disclose important behavioral traits like whether this requires authentication, rate limits, error conditions, or what happens with invalid parameters. The description doesn't contradict any annotations since none exist.

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

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

The description is appropriately sized with two sentences. The first sentence states the core purpose, and the second provides usage guidance. The parameter combination details are presented in a clear bullet-like format. There's minimal waste, though the second sentence could be slightly more concise. Overall, it's well-structured and front-loaded with the main 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 has 4 parameters with 100% schema coverage but no annotations and no output schema, the description provides adequate but incomplete context. It explains the tool's purpose and usage context, but doesn't describe what the return values look like (no output schema exists) or important behavioral aspects like error handling. For a read operation with good schema coverage, this is minimally viable but has clear gaps in behavioral transparency.

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 adds some value by explaining valid parameter combinations and stating folderId is 'preferred,' but doesn't provide additional semantic meaning beyond what's in the schema descriptions. It doesn't explain why certain combinations are required or the implications of choosing one parameter over another. 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 tool's purpose: 'Retrieve details about a specific folder including name, status, and metadata.' This specifies the verb ('retrieve'), resource ('folder'), and scope of information returned. It distinguishes from siblings like get_list or get_task by focusing on folders, but doesn't explicitly contrast with get_workspace_hierarchy which might also provide folder 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 explicit guidance on when to use this tool: 'Helps you understand folder structure before creating or updating lists.' This gives clear context about its preparatory role. It also outlines valid parameter combinations, indicating when to use folderId vs folderName+space combinations. However, it doesn't explicitly state when NOT to use it or name specific alternatives among siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the reliability difference between parameters (listId vs listName), which is useful context. However, it doesn't mention potential errors, rate limits, authentication needs, or return format, leaving gaps for a read 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 two sentences with zero waste: the first states the purpose and mandatory parameter logic, the second provides the key reliability guidance. It's front-loaded and appropriately sized 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 simple read tool with 100% schema coverage but no annotations or output schema, the description covers the essential usage logic and parameter guidance. However, it lacks details on error conditions, return format, or how it fits into the broader ClickUp hierarchy, leaving room for improvement.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds marginal value by reinforcing the reliability preference (listId over listName) but doesn't provide additional semantic context beyond what's in the schema descriptions.

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

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

The description clearly states the verb 'Retrieve' and the resource 'specific ClickUp list', making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_folder' or 'get_task' 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 explicit guidance on when to use parameters ('You MUST provide either listId or listName') and includes a clear alternative preference ('Using listId is more reliable as list names might not be unique'), which directly addresses usage decisions.

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 that task names may not be unique and that listName helps disambiguate, which adds some behavioral context. However, it lacks details on permissions, error handling, rate limits, or what 'detailed information' includes, leaving significant gaps for a read 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 highly concise and well-structured: it starts with the core purpose, then lists parameter combinations in a bullet-like format. Every sentence earns its place by clarifying usage without redundancy.

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

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

Given the complexity (a read operation with 3 parameters, no annotations, and no output schema), the description is adequate but incomplete. It covers parameter usage well but lacks behavioral details (e.g., what 'detailed information' returns) and doesn't leverage context from siblings like 'get_tasks' to clarify scope.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value by restating the parameter combinations and preferences (e.g., taskId is 'preferred'), but doesn't provide additional semantics beyond what's in the schema descriptions.

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

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

The description clearly states the verb 'retrieve' and resource 'detailed information about a specific task', making the purpose unambiguous. It doesn't explicitly differentiate from sibling tools like 'get_tasks' (which likely lists multiple tasks), but the focus on a 'specific task' implies this distinction.

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

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

The description provides explicit guidance on when to use this tool: it outlines two valid parameter combinations (taskId alone preferred, or taskName + optional listName) and warns about task name uniqueness issues. This directly addresses when to use specific parameters, though it doesn't compare to alternatives like 'get_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 the full burden of behavioral disclosure. It mentions optional filtering and pagination (via 'page' parameter), which adds useful context beyond the schema. However, it doesn't describe return format, rate limits, authentication needs, error conditions, or whether this is a read-only operation (though 'retrieve' implies reading). The description adds some behavioral context but 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 efficiently structured in three sentences with zero waste. The first sentence states the core purpose, the second provides critical parameter guidance, and the third mentions filtering capabilities. Every sentence earns its place by adding distinct value, and information is appropriately 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 8 parameters with 100% schema coverage but no annotations and no output schema, the description provides adequate but incomplete context. It covers the essential purpose and parameter guidance but lacks behavioral details about return format, pagination behavior beyond the 'page' parameter, error handling, and authentication requirements. For a retrieval tool with multiple parameters, more completeness would be beneficial.

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

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

Schema description coverage is 100%, so the schema already documents all 8 parameters thoroughly. The description adds minimal value by emphasizing the listId/listName choice and mentioning filtering capabilities, but doesn't provide additional syntax, format details, or constraints beyond what the schema specifies. With high schema coverage, baseline 3 is appropriate.

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

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

The description clearly states the verb 'retrieve' and resource 'tasks from a list', making the purpose understandable. It distinguishes from siblings like 'get_task' (singular) by indicating retrieval of multiple tasks, but doesn't explicitly contrast with other list-related tools like 'get_list'. The purpose is specific but sibling differentiation could be more explicit.

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

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

The description provides clear context for when to use specific parameters (listId preferred over listName) and mentions filtering capabilities. It doesn't explicitly state when to use this tool versus alternatives like 'get_task' (singular) or 'get_list', nor does it mention prerequisites or exclusions. The guidance is helpful but not comprehensive regarding 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?

No annotations are provided, so 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 requirements, rate limits, error handling, or the format of the returned hierarchy. This leaves significant gaps for a tool with no annotation coverage.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, making it easy to 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 tool has no parameters, no annotations, and no output schema, the description provides a basic understanding of what it does but lacks details on behavior, output format, and usage context. It's minimally viable but incomplete for effective 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 schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and it doesn't introduce any confusion, earning a baseline score of 4 for this scenario.

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 the resource ('complete workspace hierarchy including spaces, folders, and lists'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_folder' or 'get_list', which retrieve specific components rather than the entire 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?

No guidance is provided on when to use this tool versus alternatives like 'get_folder' or 'get_list'. The description implies it retrieves a broader scope, but it lacks explicit recommendations, prerequisites, or exclusions for usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the mutation behavior ('Move multiple tasks'), provides efficiency context ('efficiently'), and includes a critical warning about status resetting. However, it doesn't mention error handling, rate limits, or authentication requirements that would be helpful 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 perfectly sized with three sentences that each earn their place: purpose statement, parameter requirements, and behavioral warning. It's front-loaded with the core functionality and uses clear bullet points for the 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 and no output schema, the description provides good context about the operation, parameter requirements, and a critical behavioral warning. However, it doesn't describe what the tool returns or provide guidance on error cases, which would be helpful given the complexity of bulk operations with multiple identification methods.

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 parameters. The description adds some semantic context about parameter preferences ('taskId alone (preferred)', 'taskName + listName'), but doesn't provide additional meaning beyond what's in the schema descriptions. This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('Move multiple tasks'), the resource ('tasks'), and the scope ('to a different list efficiently'). It distinguishes from the sibling 'move_task' by specifying bulk operation and provides explicit parameter requirements that differentiate it from other task manipulation tools.

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

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

The description provides explicit when-to-use guidance by stating 'For each task, you MUST provide either: 1. taskId alone (preferred) 2. taskName + listName'. It also includes a warning about status resetting with different target list options, which helps the agent understand when this tool might have unintended consequences versus alternatives.

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 effectively warns about a critical side effect ('Task statuses may reset if destination list has different status options'), which is valuable beyond the basic 'move' action. However, it doesn't cover other potential behaviors like error conditions or permission 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 appropriately sized and front-loaded, with the core purpose stated first, followed by parameter guidelines and a critical warning. Every sentence earns its place by providing essential usage information without 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?

Given the complexity (5 parameters, no annotations, no output schema), the description is mostly complete. It covers purpose, parameter logic, and a key behavioral warning. However, it lacks details on return values or error handling, which would be helpful for a mutation tool with no output schema.

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 baseline is 3. The description adds significant value by explaining parameter combinations and dependencies (e.g., taskName requires sourceListName, preferences for taskId/listId), which clarifies usage beyond the schema's individual parameter descriptions. It doesn't fully detail all semantics but compensates well.

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 ('Move a task') and resource ('to a different list'), distinguishing it from siblings like move_bulk_tasks (bulk operations) or update_task (modifying task properties). 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 explicit guidance on when to use this tool vs. alternatives by detailing two valid parameter combinations with preferences (e.g., 'preferred' for taskId+listId/listName) and warnings about when taskName requires sourceListName. It also implicitly distinguishes from move_bulk_tasks by focusing on single-task movement.

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 mentions the bulk nature and efficiency, but doesn't disclose important behavioral traits like whether this requires specific permissions, whether updates are atomic or partial, what happens on partial failures, rate limits, or what the response looks like. For a mutation tool with zero annotation coverage, this is inadequate.

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

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

The description is extremely concise and well-structured. The first sentence establishes purpose, followed by clear bullet points for identification requirements, and a final sentence about partial updates. Every sentence earns its place with zero waste.

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 and no output schema, the description is incomplete. It doesn't address critical contextual information like authentication requirements, error handling, response format, or performance characteristics. The partial update statement is helpful but insufficient for a bulk mutation operation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema by emphasizing the identification requirements (taskId preferred, taskName requires listName) and the partial update behavior. This meets the baseline 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 ('multiple tasks'), and specifies the scope ('efficiently'). It distinguishes from siblings like 'update_task' (singular) and 'update_list' (different resource), but doesn't explicitly contrast with 'move_bulk_tasks' or 'delete_bulk_tasks' which also operate on multiple 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 implied usage guidance by specifying identification requirements (taskId alone preferred, or taskName+listName) and stating 'Only specified fields will be updated.' However, it doesn't explicitly state when to use this tool versus alternatives like 'update_task' (singular) or 'move_bulk_tasks', 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Modify' implies a mutation operation, the description doesn't address critical behavioral aspects: what permissions are required, whether changes are reversible, what happens to existing properties not mentioned, error conditions, or what the response looks like. 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 efficiently structured with three sentences: a clear purpose statement, specific parameter combination rules, and a requirement for update fields. Every sentence earns its place by providing essential information without redundancy. The front-loaded purpose statement makes the tool's function immediately clear.

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 6 parameters, no annotations, and no output schema, the description is incomplete. While it covers parameter combinations and update requirements, it lacks critical information about permissions, side effects, error handling, and response format. The absence of behavioral transparency and output information makes this inadequate for confident tool invocation despite the good parameter 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 100%, so all parameters are already documented in the schema. The description adds minimal value beyond the schema by emphasizing the preferred parameter combination (folderId alone) and stating that at least one update field must be provided. However, it doesn't provide additional semantic context about what 'override_statuses' means in practice or how name changes affect folder hierarchy.

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 ('Modify') and resource ('existing folder's properties'), making the purpose immediately understandable. It distinguishes this from creation tools like 'create_folder' and deletion tools like 'delete_folder' by focusing on modification. However, it doesn't explicitly differentiate from other update tools like 'update_list' or 'update_task' in terms of what makes folder updates unique.

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 parameter combinations: folderId alone (preferred) or folderName with spaceId/spaceName. It also states that at least one update field (name or override_statuses) must be provided. This gives clear usage rules, though it doesn't explicitly mention when to use this tool versus alternatives like 'update_list' or 'update_task' for different resource types.

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 it's an update operation with input requirements. It lacks disclosure on behavioral traits like permissions needed, whether changes are reversible, rate limits, or what happens on success/failure. 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, well-structured sentence that front-loads the core purpose and includes essential requirements without any wasted words. Every part of the sentence serves a clear purpose in guiding usage.

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

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

Given this is a mutation tool with no annotations and no output schema, the description is incomplete. It covers input requirements but lacks crucial information about what the tool actually does behaviorally (e.g., side effects, error conditions, return values). The context signals indicate complexity that isn't adequately 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?

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds minimal value by emphasizing the 'either/or' requirement for listId/listName and that at least one field must be updated, but doesn't provide additional semantic context beyond what's in the schema.

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

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

The description clearly states the action ('Update') and resource ('existing ClickUp list's properties'), making the purpose understandable. However, it doesn't explicitly differentiate this from sibling tools like 'update_folder' or 'update_task' beyond mentioning it's for lists specifically.

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

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

The description provides clear context on when to use this tool: when updating list properties, with explicit requirements ('MUST provide either listId or listName, and at least one field to update'). It doesn't mention when not to use it or alternatives among siblings, but the requirements offer practical 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: the tool modifies existing tasks, specifies that 'Only specified fields will be updated' (partial updates), and warns about task name uniqueness issues. However, it doesn't mention authentication requirements, rate limits, or error conditions.

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

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

The description is perfectly structured and concise: three sentences total, each earning its place. The first states the purpose, the second explains parameter combinations, and the third specifies update requirements. No wasted words, and information is front-loaded appropriately.

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

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

Given the tool's complexity (9 parameters, mutation operation) with no annotations and no output schema, the description does well by covering purpose, usage guidelines, and parameter semantics. However, it lacks details on return values, error handling, and system constraints like permissions or rate limits, which would be helpful for a mutation tool.

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

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

The schema description coverage is 100%, so the baseline is 3. The description adds significant value by explaining parameter combinations and constraints: it clarifies the preferred use of taskId, the disambiguation role of listName with taskName, and the requirement for at least one update field. This goes beyond the schema's individual parameter 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 tool's purpose: 'Modify an existing task's properties.' It specifies the verb ('Modify') and resource ('existing task's properties'), distinguishing it from sibling tools like create_task, delete_task, and update_bulk_tasks by focusing on individual task updates.

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 specific parameter combinations: '1. Use taskId alone (preferred if you have it)' and '2. Use taskName + optional listName (to disambiguate if multiple tasks have the same name).' It also states prerequisites: 'At least one update field (name, description, status, priority) must be provided.'

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