Enables interaction with ClickUp workspaces, providing tools for creating new tasks with various properties (descriptions, priority levels, due dates, tags), retrieving detailed task information by task ID, and looking up tasks using custom IDs.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ClickUp MCP Integration create a new task in the Marketing folder for the upcoming campaign"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol server that provides seamless integration with ClickUp, allowing Large Language Models to interact with your ClickUp workspace tasks and data.
This MCP server provides the following tools for interacting with ClickUp:
clickup_create_task: Creates a new task in your ClickUp workspace
clickup_get_task: Retrieves detailed information about a specific task using its ID
clickup_get_task_by_custom_id: Retrieves task information using a custom ID
clickup_update_task: Updates an existing task by its ID
clickup_update_task_by_custom_id: Updates an existing task by its custom ID
get_list_tasks: Gets all tasks from a list with optional filtering
clickup_search_docs: Searches for docs in a specific parent
clickup_create_doc: Creates a new doc in ClickUp
clickup_get_doc_pages: Gets all pages from a ClickUp doc
clickup_get_page: Gets a specific page from a ClickUp doc
clickup_create_page: Creates a new page in a ClickUp doc
clickup_edit_page: Edits an existing page in a ClickUp doc
clickup_get_list_custom_fields: Gets all accessible custom fields for a list
clickup_set_custom_field_value: Sets a value for a custom field on a task
clickup_set_custom_field_value_by_custom_id: Sets a custom field value using the task's custom ID
get_list_assignees: Gets all members (potential assignees) of a list
get_spaces: Gets all spaces in the workspace
get_folders: Gets all folders in a space
get_lists: Gets all lists in a folder
create_list: Creates a new list in a folder
Related MCP server: ClickUp MCP Server
Run:
npm i
npm run build
npm run inspectorDocker build:
docker buildx build -t {your-docker-repository} --platform linux/amd64,linux/arm64 .
docker push {your-docker-repository}1. Obtaining your ClickUp API Token:
Log in to your ClickUp account at app.clickup.com
Navigate to your user settings by clicking your profile picture in the bottom-left corner
Select "Settings"
Click on "Apps" in the left sidebar
Under "API Token", click "Generate" if you don't already have a token
Copy the generated API token for use in the MCP server configuration
2. Finding your Workspace ID:
Open ClickUp in your web browser
Look at the URL when you're in your workspace
The Workspace ID is the numeric value in the URL: https://app.clickup.com/{workspace_id}/home
Copy this number for use in the MCP server configuration
3. Install Docker: https://docs.docker.com/engine/install/
4a. Setup Cline MCP Server:
Open VSCode or Jetbrains IDEs and go to Cline.
Go to MCP Servers → Installed → Configure MCP Servers.
Add the following to your cline_mcp_settings.json inside the mcpServers key:
"clickup": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e",
"CLICKUP_API_TOKEN",
"-e",
"CLICKUP_WORKSPACE_ID",
"your-docker-repository"
],
"env": {
"CLICKUP_API_TOKEN": "your-api-token",
"CLICKUP_WORKSPACE_ID": "your-workspace-id"
}
}4b. Setup Claude Desktop MCP Server:
Use any editor to open the configuration file of Claude Desktop.
Windows: C:\Users\YourUsername\AppData\Roaming\Claude\claude_desktop_config.json
Mac: ~/Library/Application\ Support/Claude/claude_desktop_config.json
Add the following to your claude_desktop_config.json inside the mcpServers key:
"clickup": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e",
"CLICKUP_API_TOKEN",
"-e",
"CLICKUP_WORKSPACE_ID",
"your-docker-repository"
],
"env": {
"CLICKUP_API_TOKEN": "your-api-token",
"CLICKUP_WORKSPACE_ID": "your-workspace-id"
}
}Save the configuration file
Restart Claude Desktop to apply the changes
If you encounter issues with the MCP server:
Authentication Errors:
Verify your API token is correct
Ensure the API token has the necessary permissions for the operations you're attempting
Check that your workspace ID is correct
Task Access Issues:
Confirm you have access to the tasks you're trying to retrieve
Verify the task IDs are correct and exist in your workspace
Check if the tasks might be in an archived state
Connection Problems:
Ensure your Docker service is running properly
Check your network connection
Verify the environment variables are correctly set in your MCP configuration
This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License.
Create a new doc in ClickUp
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | The name of the new Doc | |
| parent | Yes | Parent object | |
| visibility | No | Doc visibility (PUBLIC or PRIVATE), PRIVATE by default | |
| create_page | No | Whether to create a initial page (false by default) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states 'Create' which implies a write/mutation operation, but doesn't mention required permissions, whether the operation is idempotent, error conditions, or what happens on success. For a creation tool with zero annotation coverage, this is a significant gap in behavioral context.
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 states the core function without any wasted words. It's appropriately sized for a straightforward creation tool and gets directly to the point.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a creation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what a 'doc' is in ClickUp's context, what gets returned upon creation, or any behavioral aspects. Given the complexity (4 parameters including nested objects) and lack of structured metadata, the description should provide more context about the 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 4 parameters thoroughly. The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create') and resource ('new doc in ClickUp'), making the purpose immediately understandable. It doesn't differentiate from siblings like clickup_create_page or clickup_create_task, which would require specifying what distinguishes a 'doc' from a 'page' or 'task' in ClickUp's terminology.
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 clickup_create_page or clickup_create_task. The description gives no context about prerequisites, appropriate scenarios, or exclusions, leaving the agent to infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new page in a ClickUp doc
| Name | Required | Description | Default |
|---|---|---|---|
| doc_id | Yes | ClickUp doc ID | |
| name | Yes | Page name | |
| parent_page_id | No | Parent page ID (null for root page) | |
| sub_title | No | Page subtitle | |
| content | Yes | Page content in markdown format |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a creation operation (implying mutation/write), but doesn't mention required permissions, whether it's idempotent, error conditions, or what happens on success (e.g., returns page ID). For a write tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core purpose without unnecessary words. It's appropriately sized for a straightforward creation tool and front-loads the essential information ('Create a new page in a ClickUp doc').
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 write operation with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after creation (e.g., returns page ID), error handling, or system behavior. Given the complexity of creating a page with 5 parameters and 3 required fields, more contextual information would help the agent use this tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, providing good documentation for all 5 parameters. The description adds no parameter-specific information beyond what's in the schema (e.g., it doesn't clarify format expectations or provide examples). With complete schema coverage, the baseline score of 3 is appropriate as the description doesn't enhance parameter understanding.
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 new page') and resource ('in a ClickUp doc'), making the purpose immediately understandable. It distinguishes from obvious siblings like 'clickup_create_doc' (creates docs vs pages) and 'clickup_edit_page' (edits vs creates), though it doesn't explicitly differentiate from all siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing doc), compare to similar tools like 'clickup_create_doc', or indicate when not to use it. The agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new task in ClickUp
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Task name | |
| markdown_description | No | Task description in markdown format | |
| list_id | Yes | ClickUp list ID | |
| priority | No | Task priority (1-4): 1=Urgent, 2=High, 3=Normal, 4=Low | |
| due_date | No | Due date as Unix timestamp in milliseconds | |
| tags | No | Array of tag names to add to the task | |
| time_estimate | No | Time estimate in milliseconds | |
| assignees | No | Array of user IDs to assign to the task | |
| custom_fields | No | Custom fields to set on task creation | |
| parent | No | Parent task ID to create this task as a subtask |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Create' implies a write operation, it doesn't mention authentication requirements, rate limits, error conditions, or what happens on success (e.g., returns a task ID). For a mutation tool with 10 parameters, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized for what it communicates, though it could benefit from additional context.
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 complex mutation tool with 10 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what the tool returns, error conditions, or behavioral constraints. The agent would need to guess about the response format and operational boundaries.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with each parameter well-documented in the schema itself. The description adds no additional parameter information beyond what's already in the schema, so it meets the baseline of 3 where 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 verb ('Create') and resource ('new task in ClickUp'), making the purpose immediately understandable. However, it doesn't distinguish this tool from its sibling 'clickup_update_task' or other task-related tools, which would require mentioning this is specifically for initial creation rather than modification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance about when to use this tool versus alternatives like 'clickup_update_task' or 'clickup_create_doc'. There's no mention of prerequisites (like needing a list_id) or typical use cases, leaving the agent to infer usage from the parameter schema alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Edit a page in a ClickUp doc
| Name | Required | Description | Default |
|---|---|---|---|
| doc_id | Yes | ClickUp doc ID | |
| page_id | Yes | ClickUp page ID | |
| name | No | Page name | |
| sub_title | No | Page subtitle | |
| content | No | Page content in markdown format | |
| content_edit_mode | No | Content edit mode (replace, append, prepend), default is replace |
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 'Edit a page' which implies a mutation operation, but fails to describe critical behaviors: whether this requires specific permissions, if edits are reversible, potential side effects (e.g., versioning), rate limits, or what the response looks like (no output schema). This leaves significant gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the core functionality without unnecessary words. It's appropriately sized for the tool's complexity and front-loads the essential information ('Edit a page in a ClickUp doc'). 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?
For a mutation tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It lacks behavioral context (permissions, side effects), usage guidelines, and any information about return values or error conditions. While the schema covers parameters well, the overall context for safe and effective tool invocation is insufficient.
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, providing clear documentation for all 6 parameters including their types and purposes. The description adds no additional parameter semantics beyond what's already in the schema (e.g., it doesn't explain format requirements for 'content' or clarify the relationship between 'doc_id' and 'page_id'). The baseline score of 3 reflects adequate but minimal value addition.
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 ('Edit') and resource ('a page in a ClickUp doc'), making the purpose immediately understandable. It distinguishes itself from siblings like 'clickup_create_page' (creation vs. editing) and 'clickup_get_page' (reading vs. editing), though it doesn't explicitly mention these distinctions in the description itself.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing page), exclusions, or comparisons with sibling tools like 'clickup_update_task' (for tasks vs. pages) or 'clickup_create_page' (for new pages vs. editing existing ones).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get pages from a ClickUp doc
| Name | Required | Description | Default |
|---|---|---|---|
| doc_id | Yes | ClickUp doc ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states 'Get pages' which implies a read-only operation, but doesn't disclose behavioral traits such as whether it returns all pages or paginated results, error conditions (e.g., invalid doc_id), rate limits, or authentication needs. The description is minimal and leaves key behaviors unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It's appropriately sized for a simple tool, though it could be more front-loaded with key details. The brevity is good, but it borders on under-specification given the lack of annotations.
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 (1 parameter, no output schema, no annotations), the description is incomplete. It doesn't explain what 'pages' are in ClickUp's context, the return format, or error handling. For a tool with no structured output or annotations, more descriptive context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'doc_id' documented as 'ClickUp doc ID'. The description adds no additional meaning beyond this, such as format examples or where to find the ID. With high schema coverage, the baseline is 3, and the description doesn't compensate with extra context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get pages from a ClickUp doc' clearly states the verb ('Get') and resource ('pages from a ClickUp doc'), but it's vague about what 'pages' means in this context and doesn't distinguish it from sibling tools like 'clickup_get_page' (singular) or 'clickup_search_docs'. It provides basic purpose but lacks specificity.
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 offers no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'clickup_get_page' (for a single page) or 'clickup_search_docs' (for broader document searches), nor does it specify prerequisites like needing a valid doc_id. Usage is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get all accessible custom fields for a list
| Name | Required | Description | Default |
|---|---|---|---|
| list_id | Yes | ClickUp list ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Get' implies a read-only operation, it doesn't specify authentication requirements, rate limits, pagination behavior, error conditions, or what 'accessible' means in practice. The description is too minimal for a tool that presumably interacts with external API resources.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core purpose without unnecessary words. It's appropriately sized for a simple retrieval tool and front-loads the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what format the custom fields are returned in, whether there are access restrictions, what happens with invalid list IDs, or how this differs from other custom field operations. The minimal description leaves too many operational questions unanswered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'list_id' clearly documented in the schema. The description doesn't add any additional parameter context beyond what's already in the structured schema, so it meets the baseline expectation but doesn't provide extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and target resource ('all accessible custom fields for a list'), making the purpose immediately understandable. However, it doesn't explicitly distinguish this tool from potential siblings like 'clickup_set_custom_field_value' or explain what 'accessible' means in this context, preventing a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'clickup_set_custom_field_value' and 'clickup_set_custom_field_value_by_custom_id' that modify custom fields, there's no indication whether this should be used before those operations or in what scenarios it's appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a page from a ClickUp doc
| Name | Required | Description | Default |
|---|---|---|---|
| doc_id | Yes | ClickUp doc ID | |
| page_id | Yes | ClickUp page ID |
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 'Get a page' but doesn't clarify if this is a read-only operation, what permissions are required, whether it returns content or metadata, or any rate limits. The description lacks behavioral traits beyond the basic action, leaving significant gaps for an agent to understand how to use it effectively.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse. Every part of the sentence contributes directly to understanding the tool's purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (retrieving a specific page), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'Get' returns (e.g., page content, metadata, or both), any error conditions, or behavioral context. This leaves the agent with insufficient information to use the tool correctly beyond basic parameter passing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with both parameters ('doc_id' and 'page_id') clearly documented as ClickUp IDs. The description doesn't add any meaning beyond this, such as where to find these IDs or format requirements. Since schema coverage is high, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('a page from a ClickUp doc'), making the purpose understandable. It distinguishes from siblings like 'clickup_get_doc_pages' (which lists pages) and 'clickup_edit_page' (which modifies pages), though it doesn't explicitly name these alternatives. The verb+resource combination is specific but could be more precise about what 'Get' entails.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a doc and page ID), exclusions, or compare it to siblings like 'clickup_get_doc_pages' for listing pages or 'clickup_search_docs' for finding docs. Usage is implied by the name but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a task by its ID
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | Yes |
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 it 'Get[s] a task,' implying a read-only operation, but fails to specify if it requires authentication, has rate limits, or what data is returned. For a tool with zero annotation coverage, this leaves critical behavioral traits unaddressed.
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—a single sentence with no wasted words. It front-loads the core action ('Get a task') and specifies the key input ('by its ID'), making it easy to parse quickly. Every part of the sentence serves a clear purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a task retrieval tool with no annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't cover return values, error conditions, or behavioral aspects like permissions. For a tool that likely returns structured task data, this leaves significant gaps in understanding its full 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 schema description coverage is 0%, but the description adds meaning by specifying that 'task_id' is used to retrieve a task. However, it doesn't explain the format or constraints of 'task_id' beyond what the schema's type indicates. With one parameter and low coverage, it provides basic semantics but lacks depth, aligning with the baseline for minimal compensation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('a task'), specifying it retrieves a task by its ID. It distinguishes from sibling tools like 'clickup_get_task_by_custom_id' by focusing on the standard ID, though it doesn't explicitly mention this distinction. The purpose is specific and actionable, avoiding tautology.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as 'clickup_get_task_by_custom_id' for tasks identified by custom IDs or 'clickup_update_task' for modifications. It lacks context on prerequisites or scenarios, offering only a basic functional statement without usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a task by its custom ID
| Name | Required | Description | Default |
|---|---|---|---|
| custom_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states a read operation ('Get'), implying non-destructive behavior, but lacks details on permissions, rate limits, error handling, or return format. This is inadequate for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and low schema description coverage, the description is incomplete. It doesn't address behavioral traits, return values, or usage context, leaving significant gaps for an AI agent to operate effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description adds meaning by specifying that 'custom_id' identifies a task. However, it doesn't explain the format or constraints of the custom ID beyond what the schema's string type implies. With one parameter, the baseline is 4, but the minimal semantic addition lowers the score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('a task'), specifying retrieval by custom ID. It distinguishes from sibling 'clickup_get_task' (likely by default ID) but doesn't explicitly contrast with 'clickup_update_task_by_custom_id' or other siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like 'clickup_get_task' or 'clickup_update_task_by_custom_id'. The description implies usage when you have a custom ID, but doesn't specify prerequisites, exclusions, or contextual alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for docs in a specific parent
| Name | Required | Description | Default |
|---|---|---|---|
| parent_type | Yes | Type of parent (SPACE, FOLDER, LIST, EVERYTHING, WORKSPACE) | |
| parent_id | Yes | ID of the parent |
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 searching but doesn't describe return format, pagination, error handling, or authentication needs. For a search tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core action and scope, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a search function that likely returns complex results, the description is incomplete. It doesn't cover what 'docs' includes, how results are structured, or any limitations, leaving the agent with insufficient context for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters fully. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't explain parent_type options or how parent_id is obtained). 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 action ('Search for docs') and the scope ('in a specific parent'), which distinguishes it from creation/editing tools. However, it doesn't specify what 'docs' refers to (documents, pages, etc.) or how results are returned, making it slightly less specific than ideal.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'clickup_get_doc_pages' or 'clickup_get_page', nor does it mention prerequisites or exclusions. It only states the basic function without context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Set a value for a custom field on a task
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | Yes | ClickUp task ID | |
| custom_field_id | Yes | Custom field ID | |
| value | Yes | Value to set for the custom field. Type depends on the custom field type. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Set a value' implies a write/mutation operation, it doesn't specify permissions required, whether the operation is idempotent, error handling for invalid field types, or what happens on success (e.g., no output schema is provided). For a mutation tool with zero annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core action and target, making it easy to parse. Every word earns its place by conveying essential information 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 complexity (a mutation operation with 3 parameters) and the absence of both annotations and an output schema, the description is minimally adequate. It states what the tool does but lacks behavioral details, usage context, and output information. For a mutation tool, this leaves significant gaps that could hinder correct agent invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear descriptions for all three parameters (task_id, custom_field_id, value). The description adds no additional parameter semantics beyond what's in the schema, such as explaining how to obtain the custom_field_id or format the value for specific field types. With high schema coverage, the baseline score 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 ('Set a value') and the target ('for a custom field on a task'), which is specific and unambiguous. It distinguishes this tool from siblings like clickup_update_task (which modifies core task properties) and clickup_get_task (which retrieves data), though it doesn't explicitly mention the sibling clickup_set_custom_field_value_by_custom_id as an alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention the sibling tool clickup_set_custom_field_value_by_custom_id (which likely uses a custom task ID instead of the internal task_id), nor does it explain prerequisites like needing the custom field ID from clickup_get_list_custom_fields. Usage context is implied but not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Set a value for a custom field on a task using the task's custom ID
| Name | Required | Description | Default |
|---|---|---|---|
| custom_id | Yes | ClickUp custom task ID | |
| custom_field_id | Yes | Custom field ID | |
| value | Yes | Value to set for the custom field. Type depends on the custom field type. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states the write operation ('Set a value') but doesn't mention permission requirements, whether the operation is idempotent, potential side effects, error conditions, or response format. For a mutation tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core functionality without unnecessary words. It's appropriately sized for this tool's scope and front-loads the essential information. 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?
For a mutation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't address important contextual aspects like authentication requirements, error handling, what happens on success/failure, or how the value parameter interacts with different custom field types. The 100% schema coverage helps with parameters but doesn't compensate for missing behavioral context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, providing good documentation for all three parameters. The description adds minimal value beyond the schema - it mentions 'custom field on a task' and 'custom ID' which are already covered in parameter descriptions. No additional semantic context about parameter relationships or usage patterns is provided.
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 ('Set a value') and target resource ('custom field on a task'), specifying the identifier method ('using the task's custom ID'). It distinguishes from the sibling 'clickup_set_custom_field_value' by explicitly mentioning the custom ID approach, though it doesn't fully explain the difference between these two similar 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 explicit guidance on when to use this tool versus alternatives is provided. While it implies usage for tasks with custom IDs, it doesn't clarify when to choose this over 'clickup_set_custom_field_value' (which likely uses a different identifier) or other task-update tools like 'clickup_update_task_by_custom_id'. The description offers minimal contextual direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update a task by its ID
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | Yes | ClickUp task ID | |
| name | No | Task name | |
| markdown_description | No | Task description in markdown format | |
| priority | No | Task priority (1-4): 1=Urgent, 2=High, 3=Normal, 4=Low | |
| due_date | No | Due date as Unix timestamp in milliseconds | |
| tags | No | Array of tag names to add to the task | |
| time_estimate | No | Time estimate in milliseconds | |
| assignees | No | User IDs to add or remove from the task | |
| parent | No | Parent task ID to move this task as a subtask |
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. 'Update' implies a mutation operation, but the description doesn't disclose any behavioral traits: it doesn't mention authentication requirements, rate limits, partial vs. full updates, error handling, or what happens to unspecified fields. This leaves significant gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the core purpose without any fluff. It's appropriately sized and front-loaded, with every word earning its place. No structural issues or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with 9 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects like side effects, error conditions, or response format. The agent lacks context about what a successful update entails or how to handle failures.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with each parameter well-documented in the schema itself (e.g., priority mapping, timestamp format). The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline of 3 where 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 verb ('Update') and resource ('a task by its ID'), making the purpose immediately understandable. It distinguishes this from creation tools like 'clickup_create_task' by specifying it updates existing tasks. However, it doesn't specify what fields can be updated, which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'clickup_update_task_by_custom_id' or 'clickup_set_custom_field_value', nor does it indicate prerequisites (e.g., needing an existing task ID). The agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update a task by its custom ID
| Name | Required | Description | Default |
|---|---|---|---|
| custom_id | Yes | ClickUp custom task ID | |
| name | No | Task name | |
| markdown_description | No | Task description in markdown format | |
| priority | No | Task priority (1-4): 1=Urgent, 2=High, 3=Normal, 4=Low | |
| due_date | No | Due date as Unix timestamp in milliseconds | |
| tags | No | Array of tag names to add to the task | |
| time_estimate | No | Time estimate in milliseconds | |
| assignees | No | User IDs to add or remove from the task | |
| parent | No | Parent task ID to move this task as a subtask |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Update' implies a mutation operation, the description doesn't address permissions required, whether updates are partial or complete, what happens to unspecified fields, error conditions, or rate limits. This leaves significant behavioral gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that states exactly what the tool does without any wasted words. It's perfectly front-loaded with the essential information and achieves maximum efficiency in minimal space.
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 9 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what fields can be updated, how partial updates work, what the response contains, or error handling. The combination of mutation complexity and lack of structured metadata demands more comprehensive description content.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% description coverage, providing detailed documentation for all 9 parameters including the nested 'assignees' object. The description adds no additional parameter information beyond what's already in the schema, so it meets the baseline expectation but doesn't enhance understanding of parameter usage or relationships.
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 ('a task by its custom ID'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'clickup_update_task' (which presumably updates by regular ID rather than custom ID), missing an opportunity for full sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance about when to use this tool versus alternatives like 'clickup_update_task' or 'clickup_get_task_by_custom_id'. There's no mention of prerequisites, constraints, or appropriate contexts for choosing this specific update method over others.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new list in a folder
| Name | Required | Description | Default |
|---|---|---|---|
| folder_id | Yes | ClickUp folder ID | |
| name | Yes | List name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Create a new list,' implying a write operation, but doesn't cover critical aspects like required permissions, whether the operation is idempotent, error handling, or rate limits. This leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, straightforward sentence that efficiently conveys the core action without unnecessary words. It's front-loaded and wastes no space, making it easy to parse quickly for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity as a write operation with no annotations and no output schema, the description is insufficient. It doesn't explain what happens upon success (e.g., returns a list ID), error conditions, or how it fits into the broader ClickUp ecosystem with sibling tools, leaving the agent under-informed.
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, clearly documenting both parameters ('folder_id' and 'name'). The description adds no additional semantic context beyond what the schema provides, such as format examples or constraints, so it meets the baseline for adequate but not enhanced parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create') and resource ('new list in a folder'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'clickup_create_task' or 'clickup_create_doc', which also create resources in ClickUp, leaving room for ambiguity about when to use this specific tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as sibling tools like 'clickup_create_task' or 'get_lists'. It lacks context about prerequisites, like whether the folder must exist or if there are limitations on list creation, offering minimal usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get all folders in a space
| Name | Required | Description | Default |
|---|---|---|---|
| space_id | Yes | ClickUp space ID |
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 it 'gets' folders, implying a read-only operation, but doesn't specify if it returns all folders at once, uses pagination, requires authentication, or has rate limits. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence ('Get all folders in a space') that is front-loaded with the core action. It wastes no words and directly communicates the tool's purpose without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks details on usage guidelines, behavioral traits, or output format. With no output schema, it should ideally hint at return values, but for a simple read operation, it meets a bare minimum.
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 1 parameter with 100% description coverage ('ClickUp space ID'), so the schema fully documents the parameter. The description adds no additional meaning beyond implying the 'space_id' is needed to scope the folders, which is already clear from the schema. With high schema coverage, the baseline score 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 'Get all folders in a space' clearly states the verb ('Get') and resource ('folders'), with the scope ('in a space') specified. It distinguishes from siblings like 'get_lists' or 'get_spaces' by focusing on folders, though it doesn't explicitly differentiate from non-folder tools. This is clear but lacks explicit sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a space ID), exclusions, or comparisons to sibling tools like 'get_lists' or 'get_spaces'. Without such context, users must infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get all members (potential assignees) of a list
| Name | Required | Description | Default |
|---|---|---|---|
| list_id | Yes | ClickUp list ID |
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 it 'gets' data, implying a read-only operation, but doesn't specify if it requires authentication, has rate limits, returns paginated results, or details the output format. This is a significant gap 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 front-loaded with the core action and resource, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the output looks like (e.g., list of members, their roles), behavioral aspects like error handling, or integration with sibling tools. For a tool with no structured support, more context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with the single parameter 'list_id' fully documented in the schema as 'ClickUp list ID'. The description adds no additional meaning beyond what the schema provides, such as explaining what a 'list' is in context or how to obtain the ID. Baseline 3 is appropriate when the schema handles parameter 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 action ('Get all members') and the target resource ('potential assignees of a list'), which is specific and unambiguous. However, it does not explicitly differentiate from sibling tools like 'get_lists' or 'get_folders', which deal with different ClickUp resources, so it doesn't fully distinguish from all siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context for use, or exclusions, leaving the agent to infer usage based on the tool name and description alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get all lists in a folder
| Name | Required | Description | Default |
|---|---|---|---|
| folder_id | Yes | ClickUp folder ID |
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 a read operation ('Get'), implying it's likely safe and non-destructive, but doesn't specify permissions required, rate limits, pagination, or what 'all lists' entails (e.g., maximum count, format). It lacks details on error handling or response structure, leaving gaps for a tool with potential complexity.
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 ('Get all lists in a folder') that is front-loaded with the core purpose. It wastes no words and is appropriately sized for a simple tool, earning a high score for conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, 100% schema coverage, no output schema), the description is minimally adequate. It covers the basic purpose but lacks behavioral details (e.g., permissions, pagination) and usage guidelines, which are more critical since no annotations exist. It's complete enough for a simple read tool but could be improved with more 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 schema description coverage is 100%, with the single parameter 'folder_id' fully documented in the schema as 'ClickUp folder ID'. The description adds no additional parameter semantics beyond implying the folder context, so it meets the baseline of 3 where the schema handles the heavy lifting without extra value from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get all lists in a folder' clearly states the action (Get) and resource (lists), specifying the scope (in a folder). It distinguishes from siblings like 'get_folders' (different resource) and 'get_list_assignees' (different aspect of lists), but doesn't explicitly differentiate from tools like 'create_list' or 'get_spaces' in terms of when to use each.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a folder ID), exclusions, or comparisons to siblings like 'get_folders' (for broader scope) or 'create_list' (for write operations). Usage is implied by the action but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get all spaces in the workspace
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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. 'Get all spaces' implies a read operation, but it doesn't specify whether this returns all spaces at once or uses pagination, what format the response takes, or any authentication requirements. The description is minimal and lacks important behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with zero wasted words. It's front-loaded with the essential information and doesn't contain any unnecessary elaboration. This is an excellent example of conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what a 'space' is in this context, what information is returned, or how the results are structured. The agent would need to guess about the response format and behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the schema description coverage is 100% (empty schema). The description appropriately doesn't mention any parameters since none exist. This meets the baseline expectation for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('all spaces in the workspace'), making the purpose immediately understandable. It doesn't distinguish from sibling tools like 'get_folders' or 'get_lists', but the verb+resource combination is specific enough for basic understanding.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. There are several sibling tools that retrieve different resources (folders, lists, tasks), but no indication of when spaces specifically are needed versus those other resources.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Most tools have distinct purposes targeting specific ClickUp resources (docs, tasks, lists, folders, spaces), but there is some overlap between task-related tools (e.g., clickup_update_task and clickup_update_task_by_custom_id) and custom field tools that could cause confusion if not carefully distinguished by ID type. The descriptions help clarify, but the duplication in functionality for tasks and custom fields creates minor ambiguity.
The naming is mixed: most tools use a consistent 'clickup_verb_noun' pattern (e.g., clickup_create_task, clickup_get_doc_pages), but some tools deviate with a simpler 'verb_noun' format (e.g., create_list, get_folders) without the 'clickup_' prefix. This inconsistency breaks the pattern and makes the set less predictable, though the names remain readable and descriptive overall.
With 19 tools, the count is on the higher side but reasonable for a comprehensive ClickUp integration covering docs, tasks, lists, folders, and spaces. It feels slightly heavy due to some redundancy (e.g., multiple task and custom field tools), but each tool serves a specific purpose, and the scope justifies the number to handle various operations in the domain.
The tool set provides good coverage for core ClickUp operations, including CRUD for docs, pages, tasks, lists, folders, and spaces, as well as custom field management and search. Minor gaps exist, such as no direct tools for deleting resources or managing comments/attachments, but agents can likely work around these with the available tools for basic workflows in the domain.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
A Model Context Protocol server for Wix AI tools
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
The Telnyx MCP server is an official implementation of the Model Context Protocol that enables AI clients (like Claude Desktop, Cursor, and OpenAI Agents) to interact with Telnyx's telephony, messaging, and AI assistant APIs. It provides comprehensive capabilities including making and managing phone calls, sending SMS/MMS messages, purchasing and configuring phone numbers, creating AI assistants with custom instructions, managing cloud storage buckets, scraping and embedding website content, and handling integration secrets. The server exists as both a local implementation and a remotely hosted version, allowing developers to integrate real-world communication infrastructure directly into AI applications.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Leanware-io/clickup-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
