Taskade MCP Server and Agent Plugin

Taskade is the AI-native workspace for projects, AI agents and automations. Taskade Genesis builds a running app from one prompt.

Connect Taskade to Claude, Claude Code, ChatGPT, Codex, Cursor, VS Code, GitHub Copilot, Gemini CLI, Windsurf and any other client of the Model Context Protocol.

Hosted server: https://www.taskade.com/mcp (Streamable HTTP, OAuth). Nothing to install.

This repo holds the Taskade agent plugin and two packages:

• MCP Server (@taskade/mcp-server): the local stdio server, for clients that cannot connect to a remote server.

• OpenAPI Codegen: generate MCP tools from any OpenAPI spec, not only Taskade.

Agent plugin for Claude Code, Codex, Copilot, Gemini CLI and Cursor

The taskade plugin connects your AI tool to your Taskade workspace through the hosted server, and adds 7 skills: a front door (taskade) and six jobs (getting-started, import-spreadsheet, fix-my-app, app-report, backup-my-app, plan-new-app). The skills tell the agent which tools to call, in which order, and what to check before it reports back.

• Plan: MCP access is part of every paid Taskade plan (Starter and up). Sign in once with your Taskade account.

• What it does: imports a spreadsheet into a project, fixes a Taskade Genesis app one checked change at a time, reports on your projects and automations, backs up an app to a folder, and plans a new app.

• What stays in Taskade: the plugin cannot create or edit an automation, build or publish an app, or set who can use an app. For those jobs, it writes the request for you to paste into Taskade EVE.

VS Code: turn on the chat.plugins.enabled setting. Then run Chat: Install Plugin From Source from the Command Palette and enter https://github.com/taskade/mcp.

Cursor: the Cursor plugin taskade (.cursor-plugin/) in this repository adds the same hosted server and skills.

To add only the hosted server to Codex, run codex mcp add taskade --url https://www.taskade.com/mcp, then codex mcp login taskade.

Related MCP server: Taskade MCP Server

Contents

• Agent plugin

• Taskade MCP server: quick start (Claude, Claude Code, ChatGPT, Cursor, VS Code, Windsurf)

• Hosted tools

• Example prompts

• Troubleshooting

• Local package (stdio)

• Local package tools (62)

• Why Taskade MCP?

• Agent Recipes

• OpenAPI Codegen

• What is Taskade?

• Privacy & Security

• Support

• Contributing

• License

Demo

MCP-powered Taskade agent running inside Claude Desktop by Anthropic:

Taskade MCP server: quick start

An initialize request without a token returns 401 on purpose. The 401 tells your client where to start the OAuth sign-in.

Claude (web, Desktop and mobile)

1. In Claude, go to Customize > Connectors and select Add custom connector. On a Team or Enterprise plan, an Owner first adds the connector in Organization settings > Connectors (Add, then Custom).

2. Enter the name Taskade and the URL https://www.taskade.com/mcp, then select Add.

3. Select Connect, sign in to Taskade, and approve access.

4. In a chat, select + > Connectors and turn on Taskade.

If the dialog asks for an OAuth client, select Register automatically. The connector also works in Claude Desktop and the Claude mobile apps on the same account.

Claude Code

claude mcp add --transport http taskade https://www.taskade.com/mcp

Then run /mcp in Claude Code and select taskade to sign in.

ChatGPT

ChatGPT connects to a remote MCP server as a custom connector in developer mode. It uses OAuth only.

1. In ChatGPT settings, turn on developer mode for apps and connectors.

2. Create a connector. Enter Taskade as the name and https://www.taskade.com/mcp as the server URL.

3. Select OAuth as the authentication. Sign in to Taskade and allow access.

Developer mode is available only on some ChatGPT plans, and its labels change often.

Cursor

Select Add to Cursor at the top of this page, or add this to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "taskade": {
      "url": "https://www.taskade.com/mcp"
    }
  }
}

VS Code

Select Install in VS Code at the top of this page, or run:

code --add-mcp '{"name":"taskade","type":"http","url":"https://www.taskade.com/mcp"}'

Windsurf

Add this to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "taskade": {
      "serverUrl": "https://www.taskade.com/mcp"
    }
  }
}

Other clients and servers (API token)

A client that cannot do OAuth can send a Taskade personal access token as a Bearer token. Create the token in Taskade Settings > API.

{
  "mcpServers": {
    "taskade": {
      "type": "http",
      "url": "https://www.taskade.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_TASKADE_API_TOKEN" }
    }
  }
}

Full guide: Hosted Taskade MCP.

Hosted tools

Every hosted tool declares MCP tool annotations. Claude can run a read-only tool without a confirmation, and it asks before a tool that deletes or replaces data.

• get_flow_runs: reads the recent runs of one automation, newest first. Each run has its status and times. A failed run also names the failed step and a short error. It needs edit rights on automations.

• run_flow: starts one run of an automation that is On and starts "When asked". Every run is real: it counts toward the monthly automation runs of the plan, and AI steps use credits.

The server also serves the resource taskade://getting-started, a short guide for the model.

Example prompts

1. Weekly review. "List my Taskade workspaces, read the Q4 Roadmap project, and give me the open tasks grouped by assignee." Tools: list_spaces, list_projects, read_project.

2. Plan a launch. "Create a project called Website Launch in my Marketing workspace with tasks for copy, design, QA and launch day, and set the launch task to November 3." Tools: list_spaces, create_project, create_task, set_task_date.

3. Build a support agent. "Create an agent called Help Bot in my Support workspace, add the FAQ project as its knowledge, then ask it how a customer resets a password." Tools: create_agent, add_knowledge_project, prompt_agent.

4. Close out a sprint. "In the Sprint 42 project, mark every task that mentions 'shipped' as complete, then mark the project as completed." Tools: list_tasks, complete_task, complete_project.

5. Edit a Genesis app. "In my CRM app, read app/src/App.tsx and change the page title to Acme CRM." Tools: inspect_space, write_file.

Troubleshooting

If the problem continues, open an issue or email support@taskade.com.

Local package (stdio)

Use the local package when your client supports only stdio servers, or when you need a tool that only the local package has, for example the webhook tools (subscribeWebhook, unsubscribeWebhook). It runs on your machine with npx and calls the Taskade public API over the network with a personal access token.

1. Get Your API Key

Go to Taskade Settings > API and create a Personal Access Token.

2. Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "taskade": {
      "command": "npx",
      "args": ["-y", "@taskade/mcp-server"],
      "env": {
        "TASKADE_API_KEY": "your-api-key-here"
      }
    }
  }
}

3. Cursor

Add to your Cursor MCP settings:

{
  "mcpServers": {
    "taskade": {
      "command": "npx",
      "args": ["-y", "@taskade/mcp-server"],
      "env": {
        "TASKADE_API_KEY": "your-api-key-here"
      }
    }
  }
}

4. Windsurf

Add to ~/.codeium/windsurf/mcp_config.json (or Settings → Cascade → MCP → Add Server):

{
  "mcpServers": {
    "taskade": {
      "command": "npx",
      "args": ["-y", "@taskade/mcp-server"],
      "env": {
        "TASKADE_API_KEY": "your-api-key-here"
      }
    }
  }
}

5. Cline

In VS Code, open the Cline MCP Servers panel → Configure MCP Servers and add:

{
  "mcpServers": {
    "taskade": {
      "command": "npx",
      "args": ["-y", "@taskade/mcp-server"],
      "env": {
        "TASKADE_API_KEY": "your-api-key-here"
      }
    }
  }
}

6. VS Code

Add a .vscode/mcp.json to your workspace (VS Code uses the servers key; ${input:…} prompts for your key on first run):

{
  "servers": {
    "taskade": {
      "command": "npx",
      "args": ["-y", "@taskade/mcp-server"],
      "env": {
        "TASKADE_API_KEY": "${input:taskade_api_key}"
      }
    }
  }
}

7. Remote and HTTP clients

The local package runs over stdio only. It has no HTTP or SSE mode. For a client that connects over HTTP, use the hosted server at https://www.taskade.com/mcp (see Taskade MCP server: quick start).

Local package tools (62)

The local package has its own tool names. They map to the Taskade public API v1 and v2.

Workspaces

Projects

Tasks

AI Agents

Create, manage, and publish autonomous AI agents with custom knowledge and tools.

Templates

Media

Personal

Agent Chat & Webhooks (API v2, beta)

Capabilities the v1 API doesn't have: hold a live conversation with an AI agent, and receive real-time events.

Why Taskade MCP?

Taskade MCP gives your AI assistant access to your workspace — projects, tasks, agents, knowledge bases, templates, and automations (on paid plans; some endpoints such as workspace listing are gated for free accounts). Instead of writing API code, describe what you need in natural language.

┌──────────────────────────────────────────────────────────┐
│                HOW TASKADE MCP WORKS                     │
└──────────────────────────────────────────────────────────┘

  You (in Claude/Cursor/Windsurf):
  "Create a support agent trained on our docs project"
                         ↓
  ┌──────────────────────────────────┐
  │     Taskade MCP Server           │
  │     (62 tools, 8 categories)     │
  └──────────────────────────────────┘
       ↓              ↓            ↓
  folderCreateAgent  agentKnowledge  agentPublicAccess
  (creates agent)    (attaches docs)  (publishes it)
                         ↓
  Result: Live AI chatbot trained on your data

Why MCP Instead of REST API?

Why Taskade MCP Over Other MCP Servers?

Taskade MCP includes AI agent management (create, train, deploy agents), knowledge base training (attach docs, projects, media), and OpenAPI codegen (generate MCP tools from any API spec). 62 tools across 8 categories.

Agent Recipes

Problem: Team standup notes scattered across Slack, email, and docs.

You: "Check my Taskade workspace for yesterday's completed tasks,
      summarize them as a standup update, then create today's
      priority tasks based on what's still open."

Claude uses:
  1. meProjectsGet → find your active projects
  2. projectTasksGet → pull tasks from each project
  3. taskCreate → create today's priority tasks

Result: A formatted standup summary + fresh task list in Taskade.

Problem: You have docs scattered across files and need an AI agent trained on them.

You: "Create an AI support agent called 'Help Bot' in my
      Customer Success folder, train it on our Documentation
      project, and publish it publicly."

Claude uses:
  1. workspaceFoldersGet → find "Customer Success" folder
  2. folderCreateAgent → create "Help Bot" with support instructions
  3. agentKnowledgeProjectCreate → attach Documentation project
  4. agentPublicAccessEnable → publish with shareable link

Result: Live AI chatbot trained on your docs, ready to embed.

Problem: Creating sprint projects manually every two weeks.

You: "Create a new sprint project from our 'Sprint Template',
      name it 'Sprint 2026-W15', move the top 10 backlog
      items into it, and assign them to the engineering team."

Claude uses:
  1. folderProjectTemplatesGet → find "Sprint Template"
  2. projectFromTemplate → create "Sprint 2026-W15"
  3. projectTasksGet → get backlog items
  4. taskMove → move top 10 tasks to new sprint
  5. taskPutAssignees → assign engineering team members

Result: Sprint ready to go, fully populated and assigned.

Problem: You need an agent that monitors competitors and reports findings.

You: "Generate an AI agent that researches our top 5 competitors.
      Train it on our Competitive Analysis project.
      Name it 'Market Intel Agent'."

Claude uses:
  1. folderAgentGenerate → generate agent from research prompt
  2. agentKnowledgeProjectCreate → connect Competitive Analysis project
  3. agentUpdate → refine instructions for research cadence

Result: AI research agent with domain knowledge, ready for briefings.

Problem: Each new client needs the same project structure, tasks, and materials.

You: "For our new client Acme Corp: create a project from
      the 'Client Onboarding' template, add tasks for
      kickoff meeting and SOW review, set due dates for
      the next 2 weeks, then share the project link."

Claude uses:
  1. projectFromTemplate → create "Acme Corp Onboarding"
  2. taskCreate → add kickoff, requirements, SOW tasks
  3. taskPutDate → set dates across next 2 weeks
  4. projectShareLinkEnable → generate share link

Result: Client onboarding project live and shareable in 30 seconds.

Use Cases

Project Management with AI

Ask your AI assistant to manage your Taskade workspace:

• "Show me all my projects and their status"

• "Create a new project called Q1 Planning with tasks for each team"

• "Move all overdue tasks to the Backlog project"

• "Set due dates for all tasks in the Sprint project"

AI Agent Creation

Build and deploy AI agents directly from your editor:

• "Create an AI agent called Customer Support Bot with knowledge from our docs project"

• "Generate an agent for code review using this prompt: ..."

• "Publish my agent publicly and give me the share link"

• "Add our API documentation project as knowledge to the agent"

Template Workflows

Automate project creation from templates:

• "List all templates in my workspace"

• "Create 5 new client onboarding projects from the Client Template"

• "Copy the Sprint Retrospective project for this week"

OpenAPI Codegen

Use our generator to build MCP tools from any OpenAPI spec — not just Taskade.

npm install --save-dev @taskade/mcp-openapi-codegen @readme/openapi-parser

import { dereference } from '@readme/openapi-parser';
import { codegen } from '@taskade/mcp-openapi-codegen';

const document = await dereference('your-api-spec.yaml');

await codegen({
  path: 'src/tools.generated.ts',
  document,
});

Works with any OpenAPI 3.0+ spec. Generate MCP tools for your own APIs in minutes.

What is Taskade?

Taskade (Y Combinator S19) is the AI-native workspace for building apps, deploying agents, and automating workflows from a single prompt. 150,000+ apps built.

• Genesis Apps — Build complete apps from prompts. Dashboards, CRMs, portals, forms — deployed instantly. Try it →

• AI Agents — Custom agents with built-in tools, persistent memory, multi-agent teams, public embedding

• Automations — No-code workflow automation with 100+ integrations, branching, looping, filtering

• Real-time Collaboration — Multiplayer workspace with chat, video, and multiple project views

• Templates: templates for project management, engineering, marketing, and more

• API & MCP: REST API v2, this MCP server, the agent plugin, Agent API, webhooks, OAuth 2.0

Links:

• App: taskade.com

• Create: taskade.com/create

• Apps gallery: taskade.com/apps · all categories

• Agents: taskade.com/agents

• Templates: taskade.com/templates

• Docs: taskade.com/docs · docs.taskade.com

• Workspace MCP guide: https://github.com/taskade/docs/blob/main/apis-living-system-development/workspace-mcp.md

• Hosted MCP guide: https://github.com/taskade/docs/blob/main/apis-living-system-development/genesis-app-mcp.md

• Blog: taskade.com/blog

Roadmap

See open issues for planned features and improvements.

Recently shipped (v0.1.0): Agent chat (promptAgent) and webhook triggers, live now via the Taskade API v2 tool layer.

• Automation tools: the hosted server lists automations, reads their runs and runs a "When asked" automation (list_automations, get_flow_runs, run_flow). Create, enable and manage automations through MCP are on the roadmap.

• agent.js — Open-source autonomous agent toolkit (coming soon)

• TaskOS — Agent platform at docs.taskade.com

Privacy & Security

• Hosted server. Taskade runs it on www.taskade.com. It reads and writes only the workspaces that your Taskade account can access and that are on a paid plan. The server does not read your chat history with the AI client. prompt_agent runs a Taskade agent, which can use its own tools, for example web search.

• Agent plugin. The plugin holds skills (text files) and the address of the hosted server. It runs no code of its own. The backup skill writes workspace files to a local folder (./taskade-backup/ unless you name another one).

• Local package. Your API token authorizes the server to call the Taskade public API (https://www.taskade.com/api/v1 and https://www.taskade.com/api/v2) on your behalf. The package sends your data to no other service. Keep the token in an environment variable, and never commit it.

• Privacy policy: taskade.com/privacy. Terms: taskade.com/terms.

• Security and vulnerability reports: see SECURITY.md.

Support

• Help center: help.taskade.com

• Email: support@taskade.com

• Bugs and feature requests: GitHub issues

Contributing

Help us improve MCP tools, OpenAPI workflows, and agent capabilities.

• Issues — Report bugs or request features

• Pull Requests — Contributions welcome

• Apps — Browse and clone community apps · categories

More from Taskade

• Taskade Docs (source) — developer documentation and API reference

• Integration Kit — open-source Zapier/n8n actions & triggers

• Taskade — platform home, including Genesis, the AI app builder

License

MIT