TL;DR: Taskade runs a hosted MCP server, so Claude Desktop and Cursor can read your workspace and edit Taskade Genesis app files. Connect at https://www.taskade.com/mcp via OAuth2+PKCE. Hosted MCP is on every paid plan. See the Anthropic MCP spec. Live workspace demo below.
Workspace DNA applied to MCP: Memory is your Taskade workspace: spaces, projects, sprint data, architecture decisions, and content briefs, all readable via hosted tools such as list_spaces and inspect_space. Intelligence is the reasoning layer: external AI clients (Claude Desktop, Cursor) connect in as MCP clients to read Memory and act on the workspace, while your Taskade agents reason over the same spaces with built-in tools. Execution is every action that fires as a result: project and task writes, write_file updates under the Taskade Genesis app/ directory only, automations triggered off an updated project, and sprint summaries posted to your team channel. Every execution logs back to Memory, keeping the loop closed.
In April 2026, a newsletter from Taskade put the shipped capability simply: Taskade speaks MCP, and it works with Claude Code and Cursor.
That was the product description. The architectural significance is larger: your workspace stops being a place you copy context out of. Claude Desktop, Cursor, VS Code, and Claude Code can read your spaces directly, create projects and agents, and write generated files back into the Taskade Genesis app/ directory, so the AI tools you already use are grounded in your real requirements instead of a pasted summary.
This guide covers that inbound path end to end: how to connect Claude Desktop and Cursor to Taskade's hosted MCP server, what the hosted tools can do (not only app code), and where the other two MCP paths stand today. Full setup steps, use cases, and a cloneable workspace demo included.
MCP Architecture: External AI Client → Taskade
Taskade hosted MCP is the inbound path: Claude Desktop, Cursor, VS Code, or Claude Code connects to https://www.taskade.com/mcp with OAuth2 and PKCE. The client can list spaces, read projects, create projects and agents, and edit Taskade Genesis app files under app/ only. Hosted MCP is on every paid plan. The Anthropic MCP spec defines the protocol.
┌──────────────────────────────────────────────────────────────────┐
│ MCP: EXTERNAL AI CLIENT ──→ TASKADE WORKSPACE │
├──────────────────────────────────────────────────────────────────┤
│ Taskade-as-Server (external AI connects IN) │
├──────────────────────────────────────────────────────────────────┤
│ Claude Desktop ──→ list_spaces (read-only) │
│ Cursor IDE ──→ inspect_space (read-only) │
│ VS Code ──→ write_file (app/ only) │
│ Claude Code ──→ (3 hosted tools) │
│ │
│ Auth: OAuth2 + PKCE (scope "mcp") │
│ Plan: Every paid plan │
│ Status: GA │
├──────────────────────────────────────────────────────────────────┤
│ Backed by the same app files Taskade EVE uses │
│ when it generates your app │
│ │
│ ▲ Memory → spaces, projects, sprint data, decision logs │
│ ■ Intelligence → read via inspect_space, write via app/ │
│ ● Execution → code lands in app/ · automations fire │
└──────────────────────────────────────────────────────────────────┘
What Is MCP (Model Context Protocol)?
Model Context Protocol is an open standard from Anthropic that defines how AI clients exchange context with tools and data sources. The specification lives at https://modelcontextprotocol.io/. Any MCP client can call any MCP server without a custom connector. Claude Desktop, Cursor, and VS Code can connect to Taskade at https://www.taskade.com/mcp using that same protocol.
The goal is to make AI integrations as simple as USB-C. One protocol. Any client. Any server. No custom connectors.
Before MCP: Every AI integration required a custom implementation. A Cursor → Notion connector required understanding Notion's specific API. A Claude → Jira connector required separate code from a Claude → Linear connector. Each integration was one-off.
After MCP: Any tool that implements the MCP server specification is immediately accessible to any MCP client. Claude Desktop, Cursor, VS Code, and any future MCP client can connect to Taskade, Notion, Linear, GitHub, Slack, and hundreds of other MCP servers using the same protocol.
Part 1: Connecting Claude Desktop to Taskade (Taskade as MCP Server)
Connect Claude Desktop to Taskade by adding https://www.taskade.com/mcp as an MCP server in Settings, then Developer, then completing OAuth2 with PKCE in the browser. Claude can list spaces, inspect projects, create projects and agents, and write files under app/ only. Hosted MCP requires a paid Taskade plan. Test the link with a list-spaces prompt.
What You Can Do
When Claude Desktop connects to Taskade as an MCP server, it can:
- List your workspaces, see all spaces the authenticated user can access (
list_spaces, read-only) - Inspect a space, browse projects, agent configurations, automation flows, and media as a virtual filesystem (
inspect_space, read-only) - Edit Taskade Genesis app source, create or update files in the Taskade Genesis app source, the
app/directory only (write_file) - Work with projects, agents, and automations, create and read projects, list automations, and create, update, or prompt an agent (
create_project,read_project,list_automations,create_agent,prompt_agent, and more)
Those are the tools you will reach for most. Hosted MCP also covers task writes and agent knowledge, so the inbound path is not app-code-only.
This means Claude's context in any conversation can include your actual Taskade workspace data, sprint tasks, project requirements, decision logs, team documentation, without copy-pasting.
Setup: Claude Desktop → Taskade
Prerequisites:
- Claude Desktop (Pro or Max plan for full MCP support)
- A paid Taskade workspace, the hosted MCP server is available on every paid plan
Step 1: Open Claude Desktop Settings
In Claude Desktop, go to Settings → Developer → Add MCP Server.
Step 2: Add the Taskade MCP Endpoint
Enter the Taskade MCP server URL:
https://www.taskade.com/mcp
Give it a name ("Taskade Workspace") and save.
Step 3: Authorize via OAuth2+PKCE
Claude Desktop will open a browser window to https://www.taskade.com/mcp/auth. Log in with your Taskade account credentials. Review the permission request (list spaces, read projects, edit Taskade Genesis app source). Approve. Interactive clients use the OAuth2 mcp scope. Header-controlled scripts can use a Personal Access Token instead.
The authorization token is returned to Claude Desktop. Your Taskade credentials are never shared with Claude, only the token.
Step 4: Test the Connection
In Claude Desktop, start a new conversation and type:
List my Taskade workspaces
Claude calls the list_spaces MCP tool and returns the names of your accessible spaces. If you see your workspace names, the connection is working.
Step 5: Use Your Workspace as Context
Now you can ground Claude's responses in your actual workspace data:
Inspect my "Q2 Engineering" space and summarize what sprints are in progress
Write a code review checklist into my Taskade Genesis app source based on the patterns I've described
Inspect my product requirements document in "Product Roadmap" and suggest API endpoint names for the new feature
Part 2: Connecting Cursor to Taskade (Taskade as MCP Server)
Connect Cursor to Taskade by adding an MCP server in Settings, Features, MCP Servers, with the URL https://www.taskade.com/mcp and HTTP transport. Authorize with OAuth2 and PKCE in the browser. Cursor can then read workspace context in Composer and write generated files into the Taskade Genesis app/ directory only. Hosted MCP is on every paid plan.
Cursor supports MCP servers in its settings panel, available in Cursor 0.45+.
Step 1: Open Cursor Settings
In Cursor, go to Settings → Features → MCP Servers → Add Server.
Step 2: Configure the Taskade MCP Server
Json
{
"name": "Taskade",
"url": "https://www.taskade.com/mcp",
"transport": "http"
}
Save that server entry. The URL must be the hosted Taskade MCP endpoint, not a local workspace server.
Step 3: Authorize
Cursor will prompt you to authorize. Complete the OAuth2+PKCE flow in your browser. The token is stored in Cursor's secure credentials store.
Step 4: Reference Workspace Data in Cursor
In Cursor's Composer or Chat, you can now reference Taskade content directly:
@Taskade Read my sprint tracker and write unit tests for the in-progress features
@Taskade Check the architecture decision log before suggesting the database schema change
@Taskade Write the completed feature spec into my Taskade Genesis app source
Cursor sends these as MCP tool calls to Taskade's server. The response context flows back into Cursor's editor context. Your code suggestions are grounded in your actual project requirements.
Live Demo, Sprint Tracker:
The Sprint Tracker app is the workspace structure most useful as Cursor context: sprint backlog, in-progress tasks, completion status, and velocity notes, all accessible via MCP.
Part 3: The Other Direction, and Where It Lives
Taskade MCP has three paths that must stay distinct. Hosted MCP is inbound: an external client calls https://www.taskade.com/mcp on every paid plan. Automation MCP-as-client is outbound from a flow and runs on every plan, including Free. Agent-outbound MCP is off in production, so an agent cannot dial a remote MCP server itself.
Everything above describes Taskade as an MCP server: an external client such as Claude Desktop or Cursor connects in and calls list_spaces, inspect_space, write_file, or the project and agent tools. Hosted MCP is not app-code-only. write_file is the exception that writes only under app/.
The mirror image is Taskade as an MCP client, reaching out to an external MCP server such as Notion, Linear, or GitHub to read a record or take an action mid-workflow. That might mean querying a Notion database for project requirements, or moving a Linear issue to done as part of a larger task, without a human bridging the two systems by hand.
That outbound direction ships as an automation step. Add the MCP Client step to any automation, give it the server address and a token if the server wants one, run List Tools to see what it publishes, then Call Tool to run one and pipe the result into the next step. It works on every plan, including Free. Your plan sets how many automation runs you get, and nothing about the step itself is gated.
One boundary to design around: a Taskade agent cannot reach a remote MCP server on its own. Agent-outbound MCP is off in production. What the agent can do is read the project, make the judgment call, and hand the outbound work to an automation step, then read the result back. If you are sketching architecture, draw the MCP hop inside the flow, not inside the agent.
The rest of the outbound toolkit
For services that publish no MCP server at all, automations plus native integrations cover the same ground:
- 100+ bidirectional integrations, triggers pull events into Taskade, actions push data out to the tools you already run
- Automations chain those actions together on a schedule or off a trigger, so a status change in a project can post to your team channel or update an external record
- AI Agents v2 bring built-in tools, including web search, code execution, and file analysis, to reason over a project before an automation fires
The workflows people usually want from outbound MCP, keeping a sprint board and an issue tracker in step, or syncing an editorial calendar to an external content database, are buildable either way: through the MCP Client step when the far end speaks MCP, and through a native integration when it does not.
Live Demo, Content Calendar Planner:
Why Taskade MCP Works the Way It Does
Taskade hosted MCP is not limited to app source. A connected client can list spaces, read projects, create projects, manage and prompt agents, and list automations. The write_file tool is the exception: it writes only under the Taskade Genesis app/ directory. That split keeps workspace data readable while app files stay the only code path.
Taskade's hosted MCP server lets a connected assistant read your workspace, create projects and agents, and edit your Taskade Genesis app.
This matters, because those operations run on the same foundation Taskade EVE uses internally:
- Consistent: what Claude Desktop reads is the same representation Taskade EVE uses to build apps
- Contextual: it carries structural relationships, which agents belong to which spaces and which automations connect which projects, not just flat file contents
- Safe: write operations go through the same validation layer as native agent edits; no MCP client can corrupt workspace structure
When Cursor reads your sprint tracker via MCP, it gets the same structured view Taskade EVE would use to generate a new automation around that tracker. The tool chain is coherent.
Full Engineering Sprint Workflow: Cursor Grounded in Your Sprint
A typical Cursor sprint flow starts with inspect_space on the engineering workspace, then writes tests or specs from that live context. Cursor can write files back with write_file into app/ only, and a Taskade automation can post the result to Slack. Hosted MCP supplies the inbound read and write. The automation path stays separate.
Security Model for MCP Connections
Claude Desktop and Cursor reach Taskade only after you approve OAuth2 with PKCE in the browser. They see spaces your account can see, and write_file is limited to the Taskade Genesis app/ directory. You can revoke the token from workspace settings. Agent-outbound MCP stays off in production, so remote MCP calls run only inside automations you configured.
What MCP Clients Can Access
When you authorize Claude Desktop or Cursor to connect to Taskade:
- They can list and read workspaces you have access to (
list_spaces,inspect_space) - They can edit the Taskade Genesis app source (
app/directory) in spaces you have write permission on (write_file), and create or update projects and agents with the matching write tools - They cannot access spaces or projects you do not have permission to view
- They cannot modify workspace settings, billing, or team member permissions
- The authorization scope is explicit. You review permissions before approving
Token Management
OAuth2 tokens are:
- Stored in the connecting application's credential store (not in Taskade servers)
- Revocable at any time from your Taskade workspace settings → Integrations → MCP Connections
- Scoped to specific permissions, read-only tokens are possible for clients that only need inspection
External Service Security
Outbound calls run inside automations, never from an agent acting alone, so every one of them is a step you configured and can inspect in the run history. For the MCP Client step and the integrations that push data out of Taskade:
- Each connection is independently authorized via that service's OAuth flow
- Credentials for external services are stored encrypted in your workspace
- An automation uses only the actions you have explicitly enabled for that connection
- Outbound actions are logged in your workspace automation history
MCP Use Cases: From Development to Content to Product
Hosted MCP use cases are inbound: an external AI client reads Taskade context and writes back through the hosted tools. Engineering teams ground Cursor in sprint tasks. Content teams ground drafts in briefs. Product teams ground feature work in specs. write_file still lands only in app/. Project and agent tools cover the rest of the workspace.
Every row below runs on the hosted MCP server, an external AI client reading or writing your workspace.
For Engineering Teams
| Use Case | MCP Tool | Benefit |
|---|---|---|
| Cursor reads sprint tasks for context | inspect_space |
Code suggestions grounded in actual requirements |
| Claude Desktop summarizes in-progress sprints | inspect_space |
Status answers without opening the board |
| Claude Code reads requirements before a task | inspect_space |
Agentic work starts from the real spec |
| Claude writes code output to Taskade Genesis app source | write_file |
Generated code lands directly in your app's app/ directory |
For Content Teams
| Use Case | MCP Tool | Benefit |
|---|---|---|
| Claude reads content brief from Taskade | inspect_space |
AI writing grounded in your actual brief |
| Cursor pulls the editorial calendar into context | inspect_space |
Drafts match the scheduled angle and keywords |
| Claude writes a finished draft to app source | write_file |
Output lands in the workspace, not a chat log |
For Product Teams
| Use Case | MCP Tool | Benefit |
|---|---|---|
| Cursor reads product requirements for context | inspect_space |
Feature code aligned with actual spec |
| Claude Desktop audits specs across spaces | list_spaces |
Cross-project review without copy-paste |
| Claude writes the feature spec into app source | write_file |
Spec and app source stay together |
Quick Reference: Copy-Paste MCP Configurations
The fastest production setup is a JSON MCP config that points at https://www.taskade.com/mcp with HTTP transport and OAuth2 PKCE. Drop the block into Claude Desktop, Cursor, or a generic MCP client, restart, then authorize in the browser. The Anthropic spec at https://modelcontextprotocol.io/ describes the same client-to-server contract used by every hosted MCP tool.
Most MCP setup guides describe what to click. The production-grade approach is to configure MCP via JSON config files that travel with your dotfiles. Below are the canonical configs for the three most-used MCP clients: copy, paste, restart, done.
claude_desktop_config.json: Claude Desktop
Location:
- macOS:
~/Library/Application Support/Claude/claude_desktop_config.json - Windows:
%APPDATA%\Claude\claude_desktop_config.json
Json
{
"mcpServers": {
"taskade": {
"url": "https://www.taskade.com/mcp",
"transport": "http",
"auth": {
"type": "oauth2",
"flow": "pkce"
}
}
}
}
Restart Claude Desktop. The taskade server appears in Settings → Developer → MCP Servers. Click "Authorize" to complete the OAuth2+PKCE flow in your browser. list_spaces, inspect_space, and write_file become available as tool calls in every Claude Desktop conversation.
.cursor/mcp.json: Cursor IDE (Cursor 0.45+)
Location: .cursor/mcp.json in your project root (or ~/.cursor/mcp.json for global).
Json
{
"mcpServers": {
"taskade": {
"url": "https://www.taskade.com/mcp",
"transport": "http",
"description": "Taskade workspace: list spaces, inspect, write files"
}
}
}
Reload Cursor. The Taskade server appears in Settings → Features → MCP. Authorize via OAuth2+PKCE. Use @Taskade in Composer or Chat to ground Cursor's context in your workspace data.
mcp.json: Generic MCP HTTP Client (VS Code, Claude Code, custom clients)
Json
{
"name": "Taskade Workspace",
"type": "http",
"url": "https://www.taskade.com/mcp",
"auth": {
"type": "oauth2",
"flow": "authorization_code_with_pkce",
"authorization_endpoint": "https://www.taskade.com/mcp/auth",
"token_endpoint": "https://www.taskade.com/mcp/token"
},
"tools": [
"list_spaces",
"inspect_space",
"write_file"
]
}
This generic config works with any MCP client that supports HTTP transport. Drop it into VS Code's MCP settings, Claude Code's ~/.claude/mcp.json, or any custom MCP client. The OAuth2+PKCE endpoints are the same across every client, your Taskade credentials stay in Taskade; only a scoped token reaches the client.
Verifying the Connection
After configuring any of the three clients, run a quick smoke test in your AI client:
List my Taskade workspaces.
If the client returns your actual space names (not a generic "I cannot access external systems" response), MCP is working. If you see an authentication error, re-run the OAuth2 flow, tokens expire on a per-client basis and require re-authorization roughly every 90 days.
Frequently Asked Questions
Claude Desktop and Cursor connect to Taskade hosted MCP on every paid plan through https://www.taskade.com/mcp. Automation MCP-as-client runs on every plan, including Free. Agent-outbound MCP is off in production. Hosted tools cover spaces, projects, agents, and automations; write_file is app/ only.
Does MCP work with Claude Code (terminal agent)?
Yes. Claude Code supports MCP servers as tool providers. The setup is similar to Claude Desktop, add Taskade as an MCP server in your Claude Code configuration file. Claude Code can then use list_spaces, inspect_space, and write_file as tool calls within any agentic task. This is particularly useful for Claude Code agents that need to read requirements from Taskade and write generated code into your Taskade Genesis app.
Can I limit what Claude Desktop can do with my Taskade workspace?
Yes, through your workspace role rather than through the connection itself. The hosted server issues a single mcp scope today, so there is no read-only toggle to pick during authorization. What bounds the client is your own access: it acts as you, so it reaches only the spaces your account can already reach, and each write is checked against your role. Give a client a narrower reach by connecting from an account with a lower role, such as Viewer. You can revoke the authorization at any time from your workspace settings. If Claude Desktop tries to open a project your account cannot read, the MCP server returns a permissions error.
Is MCP stable enough for production workflows?
Taskade MCP is labeled beta in source, and the tool surface has grown with each release. Reads, project and task edits, and agent work are all exposed today, and you can ask an agent a question over MCP. What is still not exposed is authoring an automation or uploading a media file. Complex workflow automation from an external MCP client is better handled by Taskade's native automations until the full MCP surface stabilizes.
What happens if an external service is unavailable mid-workflow?
If an integrated service (Notion, Linear) is unreachable during an automation, Taskade handles the failure gracefully, the run logs the error, retries according to the configured retry policy, and the workspace continues operating. Failures in an external service do not cascade into broader workspace failures.
How does MCP compare to Zapier or Make for integrations?
Zapier and Make are trigger-based automation platforms: event A triggers action B. MCP is a context-sharing protocol: a connected AI client can dynamically decide what to read or write based on the current task. MCP is more flexible (the client chooses tools in context) but requires an AI client on the other end. Zapier/Make are simpler for fixed trigger-action flows but cannot adapt to unstructured tasks. Taskade uses both: MCP for grounding external AI clients in your workspace, and integrations for high-volume trigger-action automation.
Get Started with MCP and Taskade
Start with hosted MCP: add https://www.taskade.com/mcp to Claude Desktop or Cursor, then complete OAuth2 with PKCE. That inbound path is on every paid plan and is not limited to app code. Use an automation MCP Client step when Taskade must call an external server. Open a live workspace from Taskade Genesis if you need a demo.
The hosted MCP server puts your workspace at the center of your AI tool stack. Claude Desktop and Cursor read your actual requirements instead of a pasted summary, and the files they generate land back in your Taskade Genesis app source. The context loop closes without manual relay.
This is what "AI-connected workspace" means in practice: not one tool with AI features, but a system where the AI tools you already use have access to every relevant piece of context, and their output flows back to the right place.
Workspace DNA: How MCP Extends the Intelligence Layer
Workspace DNA is the operating architecture that makes MCP coherent, not just a collection of API hooks:
- ▲ Memory (Projects + Knowledge), your Taskade workspace is the Memory layer: spaces, projects, sprint data, architecture decisions, product requirements, content briefs. The
list_spacesandinspect_spaceMCP tools expose this Memory to any AI client. What Claude Desktop reads is the same structured representation Taskade EVE uses to build apps, not a flat text dump, but a full context graph with relationships between agents, automations, and projects. - ■ Intelligence (AI Agents v2), the intelligence layer spans two kinds of reasoner over the same Memory. External AI clients (Claude Desktop, Cursor) reason over it to produce better code, documents, and analysis grounded in real requirements. Your own Taskade agents reason over it natively with built-in tools, including web search, code execution, and file analysis, so the same context serves whichever model is doing the thinking.
- ● Execution (Automations): MCP writes are not one-off edits; they are the trigger layer for automated execution. When Claude Desktop writes a sprint summary into your app source via
write_file, that change can immediately trigger a Slack automation. When a draft is marked ready, an automation pushes it onward through your 100+ integrations. Every execution feeds back to Memory, keeping context current across the stack.
Related reading:
- AI Thinking Modes Explained: Per-Agent Reasoning
- How to Build an AI Team Knowledge Base
- 7 Best AI Content Calendar Tools 2026
- Claude Code Alternatives: 5 Better Tools for Non-Developers
- Best AI App Builders 2026
- Your Workspace Is a Computer
- Founder Operating System
- Browse Cloneable Taskade Genesis App Demos
- Explore Automation Integrations →
- Browse AI Agent Apps →
- Explore the AI App Builder →
- Browse the Community Gallery →
- Wiki: Workspace DNA →
- Wiki: Autonomous AI Systems →