clickup

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

The annotation declares destructiveHint=true, but creating a task is not destructive. The description says 'WRITE: create a new task', which contradicts the destructive hint. Per the rubric, this is an annotation contradiction, and the score is 1.

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?

One concise, front-loaded sentence with the 'WRITE:' prefix, a specific verb+resource, and the REST endpoint. No wasted words.

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

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

There is no output schema, and the description does not mention what the tool returns (e.g., the created task ID), error conditions, or authentication requirements. Combined with the contradictory destructive annotation, the description is incomplete for a create operation with 11 parameters.

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 baseline is 3. The description adds that 'name' is required and that list_id is a path parameter, but the schema already states these facts, providing minimal extra value beyond the schema.

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

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

The description uses a specific verb ('create') and resource ('a new task in a list'), includes the exact REST endpoint, and clearly distinguishes it from sibling tools like update_task and create_task_comment.

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 clearly states the operation (create a new task) and emphasizes that list_id is a path parameter rather than a body field, which guides correct invocation. However, it does not explicitly explain when to prefer this over alternatives or mention scenarios like subtask creation via the parent parameter.

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 destructiveHint=true, and the description says 'WRITE: add a comment', which is consistent. The description adds the REST endpoint but does not disclose side effects, idempotency, or permissions. No contradiction 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, focused sentence that is front-loaded with the operation type and clearly presents the key information. It is concise with no unnecessary filler.

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

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

Given the tool's simplicity, full schema coverage, and annotations, the description is sufficient for an agent to invoke it correctly. It lacks return-value details, but no output schema exists, and the core purpose is well covered.

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 parameters are fully documented. The description repeats that comment_text is required and task_id is a path param without adding additional semantic meaning beyond the schema.

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

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

The description clearly states 'add a comment to a task' with a specific verb and resource. It distinguishes itself from sibling tools like create_task (creating tasks) and get_task_comments (reading comments).

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 'WRITE:' prefix and 'add a comment' clearly imply when to use this tool (write context) as opposed to read-only siblings. However, it does not explicitly name alternatives or state when-not-to-use, so it falls short of a 5.

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, and the description confirms a read operation with 'Get'. It adds valuable context about the ClickUp API token and the specific REST endpoint (GET /user), enhancing understanding of authentication and scope beyond the annotation hint.

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 consists of two short, front-loaded sentences with no filler. It states the main action first and includes the REST endpoint for reference, effectively using every word.

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, parameterless tool with no output schema, the description sufficiently explains what it does and its authorization context. No additional return-value details are necessary for this resource type.

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

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

The tool has zero parameters, and the schema confirms no required inputs. With 100% schema coverage and no parameters to describe, the baseline of 4 for zero-parameter tools applies appropriately.

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 'Get the user associated with the current ClickUp API token' with a specific verb (Get), resource (user), and scope (current token). This distinguishes it from sibling tools focused on tasks, lists, spaces, etc.

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 the token association and the REST endpoint, making the usage obvious. While it doesn't explicitly list alternatives or exclusions, the tool's unique resource scope among siblings makes the intended use clear.

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 annotation readOnlyHint=true already conveys the safe read-only nature. The description adds no behavioral detail beyond that, such as response format, pagination, ordering, or authorization. The REST endpoint reference is an implementation detail, not a behavioral trait.

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 concise sentences with no filler. The primary action is front-loaded in the first sentence, and the REST endpoint is a helpful supplementary detail. Every word earns its place.

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?

This is a simple read-only tool with a single parameter and clear annotations, but there is no output schema and the description does not mention return structure, pagination, or potential pitfalls. For a basic fetch operation, the description is marginally adequate but leaves significant unknowns for the agent.

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

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

The input schema has 100% coverage for list_id with a basic description. The tool description adds no additional meaning about the parameter, its constraints, or format. Given high schema coverage, the baseline of 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 action ('Get the comments') and the resource ('on a list'), which is specific and unambiguous. It distinguishes from sibling tools like get_task_comments by explicitly referencing the list, not a task. The REST endpoint further clarifies the target.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or provide context about when list comments are relevant. The description only states what it does, leaving the agent to infer appropriate 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?

Annotations already provide readOnlyHint=true, covering the read-only nature. The description adds the REST GET method and single-task scoping, but no further behavioral details such as error handling, response format, or effects of include_subtasks. Given annotation coverage, this is acceptable but minimal.

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

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

The description is a single sentence that conveys the core purpose and REST endpoint without any wasted words. It is optimally concise while remaining informative.

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

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

For a simple read-only tool with two documented parameters, the description is complete enough. There is no output schema, but the simple nature of the operation does not demand extensive return-value documentation. Slightly more context about what is returned could push it to 5, but it is adequate as is.

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 both task_id and include_subtasks fully described in the input schema. The description does not add any parameter-level meaning beyond the schema, so a baseline of 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 states a specific verb ('Get'), resource ('task'), and scope ('by id'), clearly distinguishing it from sibling tools like clickup_get_tasks which retrieves multiple tasks. The REST endpoint reference adds precision.

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 implicitly clarifies when to use this tool: when you have a task id and want a single task. It does not explicitly name alternatives or exclusion criteria, but the contrast with clickup_get_tasks is evident from the sibling list.

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, so the safe read nature is established. The description adds the REST endpoint, but no additional behavioral details such as pagination, ordering, or whether replies are included. Overall, it provides only marginal extra context beyond the annotation.

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 short sentences, immediately front-loaded with the action. The REST endpoint line adds useful reference without redundancy. No wasted words.

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

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

For a simple read-only tool with one parameter, the description covers the core purpose. However, it doesn't mention response shape or potential limitations like pagination, which an agent might need. Given the lack of output schema, a bit more context could be added, but it's still mostly complete.

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

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

The input schema fully documents the only parameter, task_id, with a clear description. The tool description does not add further semantic meaning beyond what the schema provides. Following the rubric, high schema coverage yields a baseline of 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 'Get the comments on a task,' using a specific verb and resource. It distinguishes from sibling tools like get_task and get_list_comments by focusing on task-specific comments. The REST endpoint reinforces the scope.

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 does not explicitly state when to use this tool over alternatives like get_list_comments. It only provides the purpose, which implies usage when a task_id is available. No exclusions or alternative recommendations are given, so the guidance is minimal.

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 annotation readOnlyHint=true is consistent with the 'Get' verb. The description adds that filters and pagination are supported, but this is already evident from the schema. It doesn't disclose additional behavioral aspects such as response structure or default pagination limits, though the annotation reduces the burden.

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 concise: one sentence for purpose and one for the REST endpoint. Every sentence carries intent, though the REST reference is extra and not strictly necessary for an agent. No redundant content.

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 operation with a rich schema, the description covers the core functionality. However, it doesn't mention the return format or how this differs from searching tasks, and the lack of an output schema leaves some ambiguity. Given the tool's complexity, slightly more guidance would improve completeness.

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

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

All 11 parameters have detailed descriptions in the schema (100% coverage). The description only summarizes 'optional filters and pagination' without adding new parameter-level semantics, so it doesn't provide value beyond what the schema already offers.

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 retrieves tasks within a specific list, using the verb 'Get' and specifying the resource. It distinguishes from sibling tools like clickup_get_task (singular) and clickup_search_tasks by anchoring to a list context, though it doesn't explicitly name those 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 includes 'with optional filters and pagination,' indicating parameters and pagination usage. However, it provides no explicit guidance on when to prefer this tool over clickup_search_tasks or other siblings, nor does it mention exclusions when to avoid using 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 readOnlyHint annotation already signals this is a safe read operation. The description adds the context of 'not inside a folder' and the REST endpoint, but does not disclose other behaviors like pagination, rate limits, or response structure. This is adequate but not rich.

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 short sentences: one defining the tool's purpose and one indicating the underlying REST endpoint. No unnecessary words or repetition, making it highly concise and well-structured.

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

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

For a simple list operation with 2 parameters and no output schema, the description covers the essential purpose and endpoint. It lacks explicit mention of return format or pagination, but the schema handles parameter details. Overall, it is sufficiently complete for its simplicity, though it could hint at response contents.

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% for both parameters (space_id, archived). The description does not add any parameter-specific meaning beyond what the schema already provides, so it meets the baseline but does not exceed it.

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 lists lists that live directly in a space, explicitly excluding folders. This provides a specific verb ('List'), resource ('lists'), and scope ('folderless'), distinguishing it from sibling tools like list_lists that might include all lists.

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 when to use this tool (for lists directly in a space, not inside a folder) and distinguishes it from a general list tool. However, it does not explicitly name alternatives or state 'use this instead of list_lists when...', so it lacks the explicit exclusions needed for a 5.

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 readOnlyHint annotation already signals a safe read operation, and the description adds the REST endpoint as an implementation detail. However, it does not disclose response behavior, pagination, or the effect of the archived parameter (though archived is documented in the schema). Overall, it adds minimal extra context beyond the annotation, so a 3 is appropriate.

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

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

The description is two short sentences, immediately stating the purpose and the REST endpoint. It is front-loaded, free of fluff, and every sentence contributes useful information, making it highly concise and well-structured.

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

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

For a simple list tool with robust schema annotations and no output schema, the description is adequate. It clearly states the action and resource, and the REST endpoint adds useful context. However, it lacks guidance on when to use it versus sibling tools and provides no info about return values, which is a minor gap. Overall, it is sufficiently complete for its simplicity.

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 both space_id and archived fully documented in the input schema. The description only repeats the 'space' context from the REST path, adding little beyond what the schema already provides. Thus, it meets the baseline of 3 without adding informative 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 'List folders in a space' clearly identifies the action (list) and the resource (folders within a space), with the REST endpoint adding precision. It does not explicitly differentiate from sibling tools like clickup_list_lists or clickup_list_folderless_lists, but the phrase 'in a space' provides enough scope to distinguish it from broader listing 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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention any preconditions, exclusions, or suggest sibling tools for different scenarios, leaving the agent to infer usage solely from the title and 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?

The readOnlyHint annotation declares the tool safe for reads, and the description adds the REST GET endpoint as confirmation. But no additional behavioral details are provided, such as pagination or return format, which is acceptable given the 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, front-loaded sentence that includes the REST endpoint, making it concise and waste-free. Every word serves a 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?

For a simple read-only list tool, the description together with the schema and annotations is complete. It states the core operation, the required resource, and the read-only nature, with no missing essential information.

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

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

The input schema describes both parameters (folder_id and archived), covering 100% of the schema. The description does not add further meaning, so the baseline score of 3 applies.

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 uses a specific verb and resource ('List the lists inside a folder'), clearly distinguishing it from sibling tools like list_folderless_lists and list_folders. The REST endpoint 'GET /folder/{folder_id}/list' adds precision.

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 context is clear: this tool is specifically for lists within a given folder, as implied by the required 'folder_id' parameter. However, it does not explicitly mention alternatives or exclusions, though the sibling tool names make the intended use evident.

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, covering safety. The description adds the REST endpoint and team scope, but does not disclose additional behaviors such as pagination, default archived handling, or rate limits. Adequate but not enriched.

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?

A single concise sentence that front-loads the core purpose. No redundant information, perfectly sized for a simple read-only 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 list tool with two well-documented parameters and a read-only annotation, the description supplies sufficient context. The REST endpoint adds clarity, and no output schema exists, but the return type is implied by 'List spaces'. Missing return details are not critical 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 coverage is 100% with both team_id and archived fully described. The description adds no parameter-specific meaning beyond the schema, so 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 action ('List') and the resource ('spaces') with a scope ('in a workspace (team)'). It distinguishes from sibling tools like list_workspaces, list_folders, and list_lists by specifying the exact entity type.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. It simply states what the tool does without contextual direction.

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

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

Annotations already declare readOnlyHint: true, lowering the bar. The description adds valuable context beyond annotations by explaining the API naming ('teams') and the endpoint (GET /team), which clarifies the source and mapping of the returned IDs. 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 two sentences, front-loaded with the primary action ('List the workspaces'), and efficiently includes the essential naming clarification and REST endpoint. Every sentence earns its place without unnecessary verbosity.

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

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

Given this is a simple zero-parameter list tool with no output schema and strong readOnly annotations, the description is complete. It conveys the purpose, the naming nuance, and the practical significance of the returned IDs (team_id), covering all necessary 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?

With zero parameters, the description does not need to explain parameter semantics; the baseline of 4 applies. The schema coverage is trivially 100% since there are no properties, and the description provides no redundant parameter info.

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

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

The description clearly states the tool lists workspaces accessible by the token, with a specific verb ('List') and resource ('workspaces'). It also distinguishes from sibling tools by clarifying the naming mapping to 'teams' and the team_id usage, making the purpose unambiguous.

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

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

The description implies when to use this tool by noting that the returned ids are the team_id used by other tools, giving context for its role in the broader workflow. However, it does not explicitly mention alternatives or exclusions, though the sibling list tools are clearly different resources.

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 readOnlyHint annotation already declares the operation is read-only, so the description doesn't need to restate that. The description adds the workspace-wide scope and API endpoint, which is useful but does not disclose other behavioral traits such as pagination behavior or result limits. Given the annotation coverage, this is adequate but not extensive.

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, front-loaded with the core purpose, and includes a helpful API reference. Every sentence earns its place, with 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?

Given the tool has 12 parameters and no output schema, the description provides the essential context: it searches/filters tasks across a workspace with optional scoping. It doesn't elaborate on return format, but the purpose is clear enough for a read-only search tool, and the schema handles parameter details. A slightly more explicit mention of what the response contains would make it fully complete.

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

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

The input schema has 100% description coverage for all 12 parameters, so the schema already explains each parameter. The description adds general context about scoping to spaces/folders/lists, which maps to existing parameters, but it doesn't provide additional semantic depth beyond what the schema already provides. 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 tool searches and filters tasks across a whole workspace, using a specific verb and resource. It distinguishes itself from siblings like clickup_get_tasks by emphasizing the workspace-wide scope, and it also references the exact ClickUp API endpoint for additional clarity.

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 provides clear context for when to use the tool: when searching/filtering tasks across an entire workspace, optionally scoped to spaces/folders/lists. It does not explicitly mention alternative tools or exclusions, but the description's emphasis on workspace-wide search differentiates it from list-specific task retrieval 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?

The annotation destructiveHint=true already indicates mutation, and the description adds the important behavioral trait that only passed fields are changed, which is beyond the annotation. It also explicitly labels the operation as 'WRITE' and provides the REST method, giving useful context beyond the structured data.

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, front-loaded with 'WRITE:' and the core action, and each sentence conveys essential information (partial update behavior and REST endpoint). There is no filler, making it appropriately 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?

With 10 parameters fully described in the schema and a destructive hint annotation, the description provides the necessary high-level context, including partial update behavior and the endpoint. It does not need to cover return values given the absence of an output schema, so it is sufficiently complete.

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

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

The input schema covers all 10 parameters with descriptions at 100% coverage, so the description does not need to elaborate. The description adds no parameter-specific semantics beyond the schema, thus the baseline score of 3 applies.

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 function with a specific verb ('update') and resource ('existing task'), and it distinguishes from sibling tools like clickup_create_task by specifying it modifies an existing task. Mentioning the REST endpoint adds additional precision.

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 (when you need to modify an existing task) but does not explicitly contrast with alternatives like create_task or state when not to use. It provides a useful hint about partial updates, but lacks explicit when/when-not guidance.

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