TL;DR: Taskade ships a native MCP server at
https://www.taskade.com/mcpthat lets Claude Desktop, Cursor, and VS Code connect to your workspace via OAuth2 + PKCE. The server exposeslist_spaces,inspect_space,edit_space,write_file, andread_file— all backed by the same Virtual File System EVE uses internally. Available on Business and above. Clone the demo, authorize the client, work cross-platform. Try Genesis free →
The anchor app is a Team Knowledge Base that becomes context for Claude Desktop, Cursor, or VS Code the moment you connect.
Click Use this app to copy the KB into your workspace. Then connect Claude Desktop or Cursor to https://www.taskade.com/mcp and your KB Projects, search Agent, and summarization Automation are immediately available as context. This is what MCP changes about workspace-to-AI-client interaction.
What MCP Is
Model Context Protocol (MCP) is the cross-vendor standard, introduced by Anthropic in late 2024, for letting AI clients consume context from third-party tools. Before MCP, every integration was a custom adapter — Cursor had its own way to read Notion, Claude Desktop had its own way to read Drive, Continue.dev had its own way to read a database. After MCP, any AI client can read from any tool that exposes an MCP server.
The protocol is simple in shape:
- The MCP client (Claude Desktop, Cursor, VS Code) initiates a session with the MCP server.
- The MCP server (Taskade, Notion, Linear, etc.) advertises a set of tools the client can call.
- The client calls the tools as the user works; the server returns structured results the client incorporates into responses.
For a workspace like Taskade, MCP is structurally important because it turns the workspace into shared context across every AI client a user touches. Your Taskade Memory becomes Claude Desktop's context, Cursor's context, and VS Code's context — without copy-paste, without re-uploading, without re-authorizing for each session.
The sequence above is the canonical MCP interaction. The user works in their AI client of choice; the client reads context and writes back through the Taskade MCP server.
Why Taskade Shipped MCP First
Taskade was one of the first SaaS workspaces to ship a native MCP server (v6.148) because the Workspace DNA model maps cleanly onto MCP's tool/resource abstractions. MCP servers advertise tools; Taskade workspaces already have a tool surface (Projects, Agents, Automations). MCP servers advertise resources; Taskade workspaces already have addressable resources (/share/apps/{id}, /spaces/{id}, /d/{projectId}). MCP servers need OAuth2; Taskade already had OAuth2 for the public API.
The shipping path was therefore short — most of the work was wiring the existing surfaces into MCP tool definitions and exposing the Virtual File System (VFS) that EVE uses internally.
The architectural picture
┌────────────────────────────────────────────────────────────────┐
│ TASKADE MCP SERVER ARCHITECTURE │
│ │
│ EXTERNAL AI CLIENTS │
│ ┌────────────────┬──────────────┬───────────────┐ │
│ │ Claude Desktop │ Cursor │ VS Code │ │
│ └────────────────┴──────────────┴───────────────┘ │
│ │ │ │ │
│ └──────────────┼────────────────┘ │
│ │ OAuth2 + PKCE │
│ ▼ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ https://www.taskade.com/mcp │ │
│ │ Taskade MCP Server │ │
│ │ │ │
│ │ Tools exposed: │ │
│ │ - list_spaces() │ │
│ │ - inspect_space(id) │ │
│ │ - edit_space(id, op) │ │
│ │ - write_file(path, content) │ │
│ │ - read_file(path) │ │
│ └──────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Virtual File System (VFS) │ │
│ │ Same VFS that EVE uses inside the app │ │
│ │ - Memory: Projects │ │
│ │ - Intelligence: Agents │ │
│ │ - Execution: Automations │ │
│ └──────────────────────────────────────────────────────┘ │
└────────────────────────────────────────────────────────────────┘
The structural insight is that the VFS is the same for external MCP clients and the internal EVE meta-agent. Both write into the same file tree, both read the same Projects, both see the same automation runs. This is what lets Claude Desktop and EVE collaborate on the same workspace.
Setting Up the Taskade MCP Server
Claude Desktop
- Open Claude Desktop → Settings → Developer → Edit Config.
- Add the Taskade MCP entry to the JSON config:Json
{ "mcpServers": { "taskade": { "url": "https://www.taskade.com/mcp" } } } - Restart Claude Desktop.
- A browser window opens for OAuth2 + PKCE authorization. Sign in to Taskade and authorize the workspace(s) you want Claude to access.
- Back in Claude Desktop, the Taskade tool surface is available — try a prompt like "What's in my Team Knowledge Base?"
Cursor
- Open Cursor → Settings → Features → MCP.
- Click Add new MCP server.
- Server URL:
https://www.taskade.com/mcp. - Complete the OAuth flow in the browser window that opens.
- Cursor's chat now has access to the Taskade tool surface.
VS Code (via Continue.dev or GitHub Copilot MCP)
- Install the Continue.dev extension or use the GitHub Copilot MCP integration.
- Open the extension's config → MCP Servers.
- Add
https://www.taskade.com/mcp. - Complete the OAuth flow.
- The Taskade workspace is now available as context.
Authorization model
The OAuth2 + PKCE flow uses short-lived access tokens (15 minutes) with refresh tokens. The MCP client never sees a long-lived API key. Permissions are scoped per workspace — when you authorize a connection, you choose which workspace(s) the client can read. You can revoke access at any time from Taskade Settings → Connected Apps.
What You Can Do With Cross-Client Context
The interesting use cases are the ones that span clients.
1. Plan in Claude Desktop, code in Cursor
You discuss a feature plan in Claude Desktop, asking it to read your product roadmap Project for context. Claude proposes an implementation plan and writes it back into a new Project as a milestone breakdown. You switch to Cursor; the same Taskade workspace is connected; Cursor reads the milestone breakdown and starts implementing the first task. Both clients are operating on the same workspace; no copy-paste between them.
2. Research in VS Code, archive in Taskade
While debugging a library, you ask VS Code (via Continue.dev) to summarize a Stack Overflow thread. You ask it to save the summary as a Project in your engineering knowledge base. The MCP write_file tool drops the summary into the workspace. Two days later, EVE inside Taskade reads the same summary when answering a teammate's question — the loop closes across clients.
3. Run an Agent from any client
The MCP inspect_space tool returns the list of Agents in the space. Calling invoke_agent (subset of edit_space) runs the Agent with a prompt from the external client. You can therefore call a Taskade Agent from Claude Desktop, Cursor, or VS Code — useful when the Agent has tooling the external client does not have.
This is the cross-client agent invocation pattern. You stay in your client of choice; the Agent runs in Taskade with full workspace context; the result flows back.
MCP Tool Surface in Detail
The Taskade MCP server exposes five tools:
| Tool | Inputs | Output | Purpose |
|---|---|---|---|
list_spaces |
(none) | array of {id, name, role} |
Enumerate accessible workspaces |
inspect_space |
space_id |
{projects[], agents[], automations[], recent_activity[]} |
Read a workspace's content |
edit_space |
space_id, operation, payload |
{success, new_state} |
Modify content (create/update/delete) |
write_file |
space_id, path, content |
{success, file_id} |
Create or update a file in the VFS |
read_file |
space_id, path |
{content, metadata} |
Read a file from the VFS |
The VFS paths follow a stable scheme:
/spaces/{spaceId}/projects/{projectId}— Project content/spaces/{spaceId}/agents/{agentId}— Agent prompt and config/spaces/{spaceId}/automations/{automationId}— Automation flow
External clients can read and write any of these paths subject to RBAC permissions.
Comparison With Other MCP Servers
Taskade is one server in a fast-growing ecosystem. The other notable MCP servers in 2026:
| MCP Server | Surface | OAuth2? | Cost |
|---|---|---|---|
| Taskade | Workspace (Projects + Agents + Automations) | Yes | V8 Business+ |
| Notion | Pages + databases | Yes | Notion paid |
| Linear | Issues + cycles | Yes | Linear paid |
| GitHub | Repos + PRs + issues | Yes | Free |
| Sentry | Errors + alerts | Yes | Sentry paid |
| Slack | Channels + messages | Yes | Slack paid |
| Anthropic Files API | Files | Yes | Anthropic API |
See MCP server comparison for the head-to-head with depth on each.
The wedge Taskade carries is the agent invocation path. Most MCP servers expose static surfaces (read pages, read issues, read errors). Taskade exposes Agents — Intelligence the external client can call, not just Memory it can read.
When MCP Matters
MCP matters when you:
- Use multiple AI clients (Claude Desktop + Cursor + VS Code) and want shared context.
- Need an external AI client to act on your Taskade workspace, not just read from it.
- Want to invoke Taskade Agents from another AI client.
- Need a stable, OAuth-secured way to connect AI clients without per-tool API keys.
MCP is overkill when:
- You only use one AI client and your work stays in one tool.
- You only need read-only context that copy-paste handles.
- Your data is so sensitive that the OAuth-token-on-laptop pattern is unacceptable.
For most teams running AI-native workflows in 2026, MCP is the future and Taskade's first-mover position is a real advantage.
Workspace DNA Meets MCP
The structural argument for Taskade MCP comes back to the Workspace DNA loop. Memory feeds Intelligence; Intelligence triggers Execution; Execution creates Memory. MCP extends the loop to external intelligence — Claude, Cursor, VS Code — without breaking it.
┌──────────────────────────────────────────────────────────────┐
│ WORKSPACE DNA + MCP │
│ │
│ ▲ MEMORY ■ INTELLIGENCE ● EXECUTION │
│ ───────── ─────────────── ───────────── │
│ Projects EVE (internal) Automations │
│ Custom fields Agents (internal) Integrations │
│ KB content │
│ ── via MCP ── │
│ Claude Desktop │
│ Cursor │
│ VS Code │
│ │
│ External AI client reads Memory │
│ External AI client writes back through VFS │
│ Loop continues — Execution + Memory creation │
│ │
└──────────────────────────────────────────────────────────────┘
External intelligence becomes part of your workspace's Intelligence layer. The loop doesn't care whether the inference happened in EVE or in Claude Desktop — the write back into Memory is the same operation.
The Bidirectional Picture
Taskade plays both sides of the MCP protocol:
- Taskade-as-Server (v6.148): external clients connect to Taskade. The use case we've described throughout this article.
- Taskade-as-Client (v6.150): Taskade Agents v2 can call out to external MCP servers (Notion, Linear, Sentry, GitHub). Agents inside Taskade can read Notion pages, query Linear issues, fetch GitHub PR diffs — all via the MCP protocol.
The bidirectional model means Taskade is the MCP hub in a multi-tool stack. Agents pull external context in via MCP; external clients push context to Taskade via MCP. The workspace becomes the always-on memory layer for the AI client ecosystem.
See MCP server comparison for the comprehensive view.
Real Workflows to Try
- Clone the Team Knowledge Base above into your workspace.
- Connect Claude Desktop to
https://www.taskade.com/mcpfollowing the setup steps above. - Ask Claude: "Summarize the onboarding section of my Team Knowledge Base." — Claude calls
inspect_space, reads the KB, and answers from your Taskade content. - Ask Claude: "Add a new doc to the KB about today's all-hands meeting." — Claude calls
write_file, creates the doc, and confirms. - Open the KB in Taskade — the doc is there.
This is the first 10 minutes of MCP + Taskade. Once you've done it once, the rest of your AI-client workflow gets organized around the workspace.
The 2026 Verdict
MCP is the cross-vendor standard for AI-client integration. Taskade shipped a native MCP server in v6.148 and a Taskade-as-client model in v6.150. The structural advantage is that your workspace becomes the brain shared across every AI client you use — Claude Desktop, Cursor, VS Code, Continue.dev, GitHub Copilot, and whatever new client ships next.
Clone the demo, authorize the client, and the Workspace DNA loop extends to wherever you do your best AI work.
Related Reading
- MCP server comparison — Taskade vs Notion vs Linear vs GitHub vs Sentry.
- Connect Claude Cursor MCP — the cross-client deep dive.
- Workspace DNA graph — the loop explained visually.
- EVE: the Genesis meta-agent — the AI inside Taskade.
- Vibe coding tools — AI clients ranked.
- Vibe workspace platforms — the workspace category.
- Best Claude Code alternatives — Claude ecosystem context.
- I built 7 AI apps in 1 day — proof by construction.
- Multi-agent interference — why agent topology matters.
▲ ■ ● Memory · Intelligence · Execution.
Frequently Asked Questions
What is the Taskade MCP server?
The Taskade MCP server (https://www.taskade.com/mcp) is a native Model Context Protocol endpoint that lets external AI clients — Claude Desktop, Cursor, VS Code, Continue.dev — connect to your Taskade workspace via OAuth2 + PKCE. The server exposes tools including list_spaces, inspect_space, edit_space, and write_file, all backed by the same Virtual File System that EVE uses inside the app. Available on V8 Business, Max, and Enterprise plans.
How do I connect Claude Desktop to my Taskade workspace?
In Claude Desktop, open Settings → Developer → Edit Config. Add an MCP server entry pointing to https://www.taskade.com/mcp with the Taskade OAuth2 flow. Claude Desktop opens a browser window for the OAuth login; once authorized, your Taskade Projects, Agents, and Automations are available as MCP tools. The connection is per-workspace, not per-account — switch workspaces by re-authorizing.
What tools does the Taskade MCP server expose?
The Taskade MCP server exposes list_spaces (enumerate accessible spaces), inspect_space (read a space's Projects, Agents, Automations, and recent activity), edit_space (modify space content via the Virtual File System), write_file (create or update a file in a space), and read_file (read a file from a space). The full surface is documented at /learn/connect/mcp.
Which plans include the Taskade MCP server?
The Taskade MCP server is included on V8 Business ($40/mo), V8 Mobile Business, V8 Max ($200/mo), and V8 Enterprise ($400/mo), plus legacy team and enterprise tiers (v3.business, v3.ultimate, v3.enterprise, v4.business, v4.ultimate, v5.team, v6.team, v6.enterprise, v7.team) and select lifetime deals. It is not available on Free, Starter, Pro, or individual-tier plans.
Is the Taskade MCP server secure?
Yes. The Taskade MCP server uses OAuth2 + PKCE (Proof Key for Code Exchange) for authentication — the same standard used by GitHub, Google, and modern mobile apps. The MCP client never sees your password or long-lived API key; the OAuth flow exchanges a code for a short-lived access token that the client refreshes. All MCP traffic is over HTTPS. Permissions are scoped to the connected workspace; you can revoke access at any time from your Taskade account settings.
What is the difference between Taskade-as-server and Taskade-as-client MCP?
Taskade-as-server (live in v6.148): external AI clients connect TO Taskade and read/write your workspace. Taskade-as-client (live in v6.150): Taskade Agents v2 can call OUT to external MCP servers including Notion, Linear, Sentry, and any compliant server. Both directions are gated to V8 Business and above. The Taskade MCP integration guide at /learn/connect/mcp explains the full bidirectional model.
Can I use Cursor with the Taskade MCP server?
Yes. Cursor supports MCP servers in the chat interface. Open Cursor Settings → Features → MCP, add a new server pointing to https://www.taskade.com/mcp, and complete the OAuth flow in the browser window that opens. Once connected, Cursor can read your Taskade Projects, Agents, and Automations as context when answering questions or making code edits.
Does the Taskade MCP server work with VS Code?
Yes. VS Code supports MCP through the Continue.dev extension and the GitHub Copilot extension's MCP integration. Both extensions accept an MCP server URL — add https://www.taskade.com/mcp and complete the OAuth flow. The MCP server is the same regardless of client; the tools and Memory surface identically across Claude Desktop, Cursor, and VS Code.
What does the MCP server expose from my workspace?
The MCP server exposes Projects (Memory), Agents (Intelligence), and Automations (Execution) from the workspaces you authorize. The Virtual File System backing edit_space and write_file is the same VFS that EVE uses to build apps — meaning external AI clients can collaborate on the same file tree EVE works in. Permissions follow your Taskade RBAC tier (Owner, Maintainer, Editor, Commenter, Collaborator, Participant, Viewer).
Why is MCP important for Taskade users?
MCP is the cross-vendor standard for letting AI clients consume context from third-party tools. By shipping a native MCP server, Taskade lets you work in Claude Desktop, Cursor, or VS Code with your full Taskade workspace as context — without copy-paste, without manual context windows, and without Zapier-style integration tax. The structural advantage is that your workspace becomes the brain shared across every AI client you use.
Is there a cloneable demo for MCP?
Yes — clone the Team Knowledge Base at /share/apps/ckhj4d7yyntrkyb8, connect Claude Desktop or Cursor to your workspace via MCP, and the AI client can immediately read the KB Projects, ask the search Agent, and trigger the summarization Automation. The clone takes one click; the MCP connection takes 60 seconds; the cross-client workflow runs immediately.