Skip to main content
Glama

By @eyaltoledano & @RalphEcom

Twitter Follow Twitter Follow

A task management system for AI-driven development with Claude, designed to work seamlessly with Cursor AI.

Related MCP server: backlog

Documentation

📚 View Full Documentation

More from Hamster

Quick Install for Cursor 1.0+ (One-Click)

Add task-master-ai MCP server to Cursor

Note: After clicking the link, you'll still need to add your API keys to the configuration. The link installs the MCP server with placeholder keys that you'll need to replace with your actual API keys.

Claude Code Quick Install

For Claude Code users:

claude mcp add taskmaster-ai -- npx -y task-master-ai

Don't forget to add your API keys to the configuration:

  • in the root .env of your Project

  • in the "env" section of your mcp config for taskmaster-ai

Requirements

Taskmaster utilizes AI across several commands, and those require a separate API key. You can use a variety of models from different AI providers provided you add your API keys. For example, if you want to use Claude 3.7, you'll need an Anthropic API key.

You can define 3 types of models to be used: the main model, the research model, and the fallback model (in case either the main or research fail). Whatever model you use, its provider API key must be present in either mcp.json or .env.

At least one (1) of the following is required:

  • Anthropic API key (Claude API)

  • OpenAI API key

  • Google Gemini API key

  • Perplexity API key (for research model)

  • xAI API Key (for research or main model)

  • OpenRouter API Key (for research or main model)

  • Claude Code (no API key required - requires Claude Code CLI)

  • Codex CLI (OAuth via ChatGPT subscription - requires Codex CLI)

Using the research model is optional but highly recommended. You will need at least ONE API key (unless using Claude Code or Codex CLI with OAuth). Adding all API keys enables you to seamlessly switch between model providers at will.

Quick Start

MCP (Model Control Protocol) lets you run Task Master directly from your editor.

1. Add your MCP config at the following path depending on your editor

Editor

Scope

Linux/macOS Path

Windows Path

Key

Cursor

Global

~/.cursor/mcp.json

%USERPROFILE%\.cursor\mcp.json

mcpServers

Project

<project_folder>/.cursor/mcp.json

<project_folder>\.cursor\mcp.json

mcpServers

Windsurf

Global

~/.codeium/windsurf/mcp_config.json

%USERPROFILE%\.codeium\windsurf\mcp_config.json

mcpServers

VS Code

Project

<project_folder>/.vscode/mcp.json

<project_folder>\.vscode\mcp.json

servers

Q CLI

Global

~/.aws/amazonq/mcp.json

mcpServers

Manual Configuration
Cursor & Windsurf & Q Developer CLI (mcpServers)
{
  "mcpServers": {
    "task-master-ai": {
      "command": "npx",
      "args": ["-y", "task-master-ai"],
      "env": {
        // "TASK_MASTER_TOOLS": "all", // Options: "all", "standard", "core", or comma-separated list of tools
        "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
        "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
        "OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
        "GOOGLE_API_KEY": "YOUR_GOOGLE_KEY_HERE",
        "MISTRAL_API_KEY": "YOUR_MISTRAL_KEY_HERE",
        "GROQ_API_KEY": "YOUR_GROQ_KEY_HERE",
        "OPENROUTER_API_KEY": "YOUR_OPENROUTER_KEY_HERE",
        "XAI_API_KEY": "YOUR_XAI_KEY_HERE",
        "AZURE_OPENAI_API_KEY": "YOUR_AZURE_KEY_HERE",
        "OLLAMA_API_KEY": "YOUR_OLLAMA_API_KEY_HERE"
      }
    }
  }
}

🔑 Replace YOUR_…_KEY_HERE with your real API keys. You can remove keys you don't use.

Note: If you see 0 tools enabled in the MCP settings, restart your editor and check that your API keys are correctly configured.

VS Code (servers + type)
{
  "servers": {
    "task-master-ai": {
      "command": "npx",
      "args": ["-y", "task-master-ai"],
      "env": {
        // "TASK_MASTER_TOOLS": "all", // Options: "all", "standard", "core", or comma-separated list of tools
        "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
        "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
        "OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
        "GOOGLE_API_KEY": "YOUR_GOOGLE_KEY_HERE",
        "MISTRAL_API_KEY": "YOUR_MISTRAL_KEY_HERE",
        "GROQ_API_KEY": "YOUR_GROQ_KEY_HERE",
        "OPENROUTER_API_KEY": "YOUR_OPENROUTER_KEY_HERE",
        "XAI_API_KEY": "YOUR_XAI_KEY_HERE",
        "AZURE_OPENAI_API_KEY": "YOUR_AZURE_KEY_HERE",
        "OLLAMA_API_KEY": "YOUR_OLLAMA_API_KEY_HERE"
      },
      "type": "stdio"
    }
  }
}

🔑 Replace YOUR_…_KEY_HERE with your real API keys. You can remove keys you don't use.

2. (Cursor-only) Enable Taskmaster MCP

Open Cursor Settings (Ctrl+Shift+J) ➡ Click on MCP tab on the left ➡ Enable task-master-ai with the toggle

3. (Optional) Configure the models you want to use

In your editor's AI chat pane, say:

Change the main, research and fallback models to <model_name>, <model_name> and <model_name> respectively.

For example, to use Claude Code (no API key required):

Change the main model to claude-code/sonnet

Table of available models | Claude Code setup

4. Initialize Task Master

In your editor's AI chat pane, say:

Initialize taskmaster-ai in my project

For new projects: Create your PRD at .taskmaster/docs/prd.txt. For existing projects: You can use scripts/prd.txt or migrate with task-master migrate

An example PRD template is available after initialization in .taskmaster/templates/example_prd.txt.

NOTE

While a PRD is recommended for complex projects, you can always create individual tasks by asking "Can you help me implement [description of what you want to do]?" in chat.

Always start with a detailed PRD.

The more detailed your PRD, the better the generated tasks will be.

6. Common Commands

Use your AI assistant to:

  • Parse requirements: Can you parse my PRD at scripts/prd.txt?

  • Plan next step: What's the next task I should work on?

  • Implement a task: Can you help me implement task 3?

  • View multiple tasks: Can you show me tasks 1, 3, and 5?

  • Expand a task: Can you help me expand task 4?

  • Research fresh information: Research the latest best practices for implementing JWT authentication with Node.js

  • Research with context: Research React Query v5 migration strategies for our current API implementation in src/api.js

More examples on how to use Task Master in chat

Option 2: Using Command Line

Installation

# Install globally
npm install -g task-master-ai

# OR install locally within your project
npm install task-master-ai

Initialize a new project

# If installed globally
task-master init

# If installed locally
npx task-master init

# Initialize project with specific rules
task-master init --rules cursor,windsurf,vscode

This will prompt you for project details and set up a new project with the necessary files and structure.

Common Commands

# Initialize a new project
task-master init

# Parse a PRD and generate tasks
task-master parse-prd your-prd.txt

# List all tasks
task-master list

# Show the next task to work on
task-master next

# Show specific task(s) - supports comma-separated IDs
task-master show 1,3,5

# Research fresh information with project context
task-master research "What are the latest best practices for JWT authentication?"

# Move tasks between tags (cross-tag movement)
task-master move --from=5 --from-tag=backlog --to-tag=in-progress
task-master move --from=5,6,7 --from-tag=backlog --to-tag=done --with-dependencies
task-master move --from=5 --from-tag=backlog --to-tag=in-progress --ignore-dependencies

# Add rules after initialization
task-master rules add windsurf,roo,vscode

Tool Loading Configuration

Optimizing MCP Tool Loading

Task Master's MCP server supports selective tool loading to reduce context window usage. By default, all 36 tools are loaded (~21,000 tokens) to maintain backward compatibility with existing installations.

You can optimize performance by configuring the TASK_MASTER_TOOLS environment variable:

Available Modes

Mode

Tools

Context Usage

Use Case

all (default)

36

~21,000 tokens

Complete feature set - all tools available

standard

15

~10,000 tokens

Common task management operations

core (or lean)

7

~5,000 tokens

Essential daily development workflow

custom

Variable

Variable

Comma-separated list of specific tools

Configuration Methods

Method 1: Environment Variable in MCP Configuration

Add TASK_MASTER_TOOLS to your MCP configuration file's env section:

{
  "mcpServers": {  // or "servers" for VS Code
    "task-master-ai": {
      "command": "npx",
      "args": ["-y", "task-master-ai"],
      "env": {
        "TASK_MASTER_TOOLS": "standard",  // Options: "all", "standard", "core", "lean", or comma-separated list
        "ANTHROPIC_API_KEY": "your-key-here",
        // ... other API keys
      }
    }
  }
}

Method 2: Claude Code CLI (One-Time Setup)

For Claude Code users, you can set the mode during installation:

# Core mode example (~70% token reduction)
claude mcp add task-master-ai --scope user \
  --env TASK_MASTER_TOOLS="core" \
  -- npx -y task-master-ai@latest

# Custom tools example
claude mcp add task-master-ai --scope user \
  --env TASK_MASTER_TOOLS="get_tasks,next_task,set_task_status" \
  -- npx -y task-master-ai@latest

Tool Sets Details

Core Tools (7): get_tasks, next_task, get_task, set_task_status, update_subtask, parse_prd, expand_task

Standard Tools (15): All core tools plus initialize_project, analyze_project_complexity, expand_all, add_subtask, remove_task, generate, add_task, complexity_report

All Tools (36): Complete set including project setup, task management, analysis, dependencies, tags, research, and more

Recommendations

  • New users: Start with "standard" mode for a good balance

  • Large projects: Use "core" mode to minimize token usage

  • Complex workflows: Use "all" mode or custom selection

  • Backward compatibility: If not specified, defaults to "all" mode

Claude Code Support

Task Master now supports Claude models through the Claude Code CLI, which requires no API key:

  • Models: claude-code/opus and claude-code/sonnet

  • Requirements: Claude Code CLI installed

  • Benefits: No API key needed, uses your local Claude instance

Learn more about Claude Code setup

Troubleshooting

If task-master init doesn't respond

Try running it with Node directly:

node node_modules/claude-task-master/scripts/init.js

Or clone the repository and run:

git clone https://github.com/eyaltoledano/claude-task-master.git
cd claude-task-master
node scripts/init.js

Join Our Team

Contributors

Star History

Star History Chart

Licensing

Task Master is licensed under the MIT License with Commons Clause. This means you can:

✅ Allowed:

  • Use Task Master for any purpose (personal, commercial, academic)

  • Modify the code

  • Distribute copies

  • Create and sell products built using Task Master

❌ Not Allowed:

  • Sell Task Master itself

  • Offer Task Master as a hosted service

  • Create competing products based on Task Master

See the LICENSE file for the complete license text and licensing details for more information.

Available Tools

36 tools
add_dependencyC

Add a dependency relationship between two tasks

Inputs: dependsOn (required), id (required), projectRoot (required), file, +1 more.

add_subtaskC

Add a subtask to an existing task

Inputs: id (required), projectRoot (required), dependencies, description, +7 more.

add_tagC

Create a new tag for organizing tasks in different contexts

Inputs: name (required), projectRoot (required), copyFromCurrent, copyFromTag, +3 more.

add_taskC

Add a new task using AI

Inputs: projectRoot (required), dependencies, description, details, +7 more.

analyze_project_complexityB

Analyze task complexity and generate expansion recommendations.

Inputs: projectRoot (required), file, from, ids, +5 more.

clear_subtasksC

Clear subtasks from specified tasks

Inputs: projectRoot (required), all, file, id, +1 more.

complexity_reportC

Display the complexity analysis report in a readable format

Inputs: projectRoot (required), file.

copy_tagC

Copy an existing tag to create a new tag with all tasks and metadata

Inputs: projectRoot (required), sourceName (required), targetName (required), description, +1 more.

delete_tagB

Delete an existing tag and all its tasks

Inputs: name (required), projectRoot (required), file, yes.

expand_allC

Expand all pending tasks into subtasks based on complexity or defaults

Inputs: file, force, num, projectRoot, +3 more.

expand_taskC

Expand a task into subtasks for detailed implementation

Inputs: id (required), projectRoot (required), file, force, +4 more.

fix_dependenciesC

Fix invalid dependencies in tasks automatically

Inputs: projectRoot (required), file, tag.

generateC

Generates individual task files in tasks/ directory based on tasks.json

Inputs: projectRoot (required), file, output, tag.

get_taskC

Get detailed information about a specific task

Inputs: id (required), projectRoot (required), complexityReport, file, +2 more.

get_tasksC

Get all tasks from Task Master, optionally filtering by status and including subtasks.

Inputs: projectRoot (required), complexityReport, file, status, +2 more.

initialize_projectA

Initializes a new Task Master project structure by calling the core initialization logic. Creates necessary folders and configuration files for Task Master in the current directory.

Inputs: projectRoot (required), addAliases, initGit, rules, +3 more.

list_tagsB

List all available tags with task counts and metadata

Inputs: projectRoot (required), file, showMetadata.

modelsB

Get information about available AI models or set model configurations. Run without arguments to get the current model configuration and API key status for the selected model providers.

Inputs: projectRoot (required), azure, bedrock, listAvailableModels, +6 more.

move_taskC

Move a task or subtask to a new position

Inputs: from (required), projectRoot (required), to (required), file, +1 more.

next_taskB

Find the next task to work on based on dependencies and status

Inputs: projectRoot (required), complexityReport, file, tag.

parse_prdA

Parse a Product Requirements Document (PRD) text file to automatically generate initial tasks. Reinitializing the project is not necessary to run this tool. It is recommended to run parse-prd after initializing the project and creating/importing a prd.txt file in the project root's .taskmaster/docs directory.

Inputs: projectRoot (required), append, force, input, +4 more.

remove_dependencyC

Remove a dependency from a task

Inputs: dependsOn (required), id (required), projectRoot (required), file, +1 more.

remove_subtaskC

Remove a subtask from its parent task

Inputs: id (required), projectRoot (required), convert, file, +2 more.

remove_taskB

Remove a task or subtask permanently from the tasks list

Inputs: id (required), projectRoot (required), confirm, file, +1 more.

rename_tagC

Rename an existing tag

Inputs: newName (required), oldName (required), projectRoot (required), file.

researchC

Perform AI-powered research queries with project context

Inputs: projectRoot (required), query (required), customContext, detailLevel, +6 more.

response-languageB

Get or set the response language for the project

Inputs: language (required), projectRoot (required).

rulesB

Add or remove rule profiles from the project.

Inputs: action (required), profiles (required), projectRoot (required), force.

scope_down_taskC

Decrease the complexity of one or more tasks using AI

Inputs: id (required), projectRoot (required), file, prompt, +3 more.

scope_up_taskC

Increase the complexity of one or more tasks using AI

Inputs: id (required), projectRoot (required), file, prompt, +3 more.

set_task_statusC

Set the status of one or more tasks or subtasks.

Inputs: id (required), projectRoot (required), status (required), complexityReport, +2 more.

updateA

Update multiple upcoming tasks (with ID >= 'from' ID) based on new context or changes provided in the prompt. Use 'update_task' instead for a single specific task or 'update_subtask' for subtasks.

Inputs: from (required), prompt (required), file, projectRoot, +2 more.

update_subtaskA

Appends timestamped information to a specific subtask without replacing existing content. If you just want to update the subtask status, use set_task_status instead.

Inputs: id (required), projectRoot (required), prompt (required), file, +2 more.

update_taskC

Updates a single task by ID with new information or context provided in the prompt.

Inputs: id (required), projectRoot (required), prompt (required), append, +3 more.

use_tagC

Switch to a different tag context for task operations

Inputs: name (required), projectRoot (required), file.

validate_dependenciesA

Check tasks for dependency issues (like circular references or links to non-existent tasks) without making changes.

Inputs: projectRoot (required), file, tag.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.1/5.0

    Scored across 36 tools

    Disambiguation3/5

    The tool set has clear distinctions for core task operations like add_task, get_task, and update_task, but there is significant overlap in complexity management tools (expand_task, expand_all, scope_up_task, scope_down_task, analyze_project_complexity, complexity_report) and in update operations (update, update_task, update_subtask), which could confuse agents about which to use. Descriptions help clarify some differences, but the boundaries are fuzzy.

    Naming Consistency4/5

    Most tools follow a consistent verb_noun or verb_adjective_noun pattern (e.g., add_task, get_tasks, set_task_status), with clear and readable names. There are minor deviations like 'models' and 'response-language' that use different conventions, but overall the naming is predictable and aids usability.

    Tool Count2/5

    With 36 tools, the count is excessive for a task management server, leading to a heavy and potentially overwhelming interface. While the domain is broad, many tools (e.g., expand_all, scope_up_task, complexity_report) could be consolidated or made optional, making the set feel bloated and difficult to navigate efficiently.

    Completeness5/5

    The tool surface provides comprehensive coverage for task management, including full CRUD operations (add_task, get_task, update_task, remove_task), dependency handling, tagging, subtask management, project initialization, and advanced features like AI integration and complexity analysis. There are no obvious gaps; agents can handle end-to-end workflows without dead ends.

    Maintenance

    ActivityInactive
    ResponsivenessMostly unanswered

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      A comprehensive and efficient Model Context Protocol server for task management that works with Claude, Cursor, and other MCP clients, providing powerful search, filtering, and organization capabilities across multiple file formats.
      5
      224 npm
      47
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Persistent, cross-session task management for Claude Code. 24 MCP tools for tasks, projects, dependencies, and docs. 7 skills for planning, standups, and handoffs. Event-sourced storage with per-project isolation.
      5
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      A task management MCP server for AI-driven development, enabling creation, tracking, and organization of tasks with subtasks, priorities, and dependencies via natural language commands.
      13
      MIT