TL;DR: Taskade runs a hosted MCP Server, so Claude Desktop and Cursor can read your workspace and edit your Genesis app source. Taskade Genesis connects at https://www.taskade.com/mcp via OAuth2+PKCE. The hosted MCP server is available on every paid plan. Live workspace demo below.
Workspace DNA applied to MCP: Memory is your Taskade workspace, spaces, projects, sprint data, architecture decisions, content briefs, all accessible via the list_spaces, inspect_space, and write_file MCP tools. Intelligence is the reasoning layer: external AI clients (Claude Desktop, Cursor) connect in as MCP clients to read Memory and edit your Genesis app source, while your Taskade agents reason over the same spaces with 34 built-in tools. Execution is every action that fires as a result: code written from your actual specs into the app/ directory, automations triggered off an updated project, 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 and write generated code back into your Genesis app source, so the AI tools you already use are grounded in your real requirements instead of a pasted summary.
This guide covers that direction end to end: how to connect Claude Desktop and Cursor to Taskade's hosted MCP server, what the tool catalog can do, and where the reverse direction of the protocol stands today. Full setup steps, use cases, and a cloneable workspace demo included.
MCP Architecture: External AI Client → Taskade
┌──────────────────────────────────────────────────────────────────┐
│ 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 (Pro $10/mo+) │
│ 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 systems exchange context with tools and data sources. The goal: 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)
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 your Genesis app source, create or update files in the 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 three are the tools you will reach for most. The hosted server exposed 18 tools as of July 2026, and the catalog is still growing.
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 Genesis app source). Approve. The hosted server uses the OAuth2 mcp scope, Personal Access Tokens are rejected.
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 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)
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"
}
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 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 What to Use Instead
MCP is a two-sided protocol, so it is worth understanding the direction this guide has not covered. 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, or write_file.
The mirror image is Taskade as an MCP client, where one of your own Taskade agents is the thing making the call, reaching out to an external MCP server such as Notion, Linear, or GitHub to read a record or take an action mid-workflow. In that model an agent might query a Notion database for project requirements, or move a Linear issue to done as part of a larger task, without a human bridging the two systems by hand.
Taskade-as-MCP-Client is not available on any plan, so there is nothing to configure in your workspace today and no plan that unlocks it. If you are planning architecture around MCP right now, build against the hosted server described in Parts 1 and 2, which is live on every paid plan.
What to use today instead
For pushing data out of Taskade to another system, the shipping path is automations plus native integrations, not MCP:
- 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 34 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 on that stack now.
Live Demo, Content Calendar Planner:
Why Taskade MCP Works the Way It Does
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
Security Model for MCP Connections
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 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 MCP is not generally available, so no agent of yours is calling an external MCP server today. For the integrations that do 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
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 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
Most MCP setup guides describe what to click. The actual 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
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. The OAuth2 authorization flow requests specific permission scopes. You can authorize read-only access (list and inspect only) without granting write permissions. You can also revoke the authorization at any time from your workspace settings. Individual project-level permissions also apply, if Claude Desktop tries to access a project your account does not have read access to, the MCP server returns a permissions error.
Is MCP stable enough for production workflows?
Taskade MCP is in beta as of May 2026. The core tools (list, inspect, write) are stable. Advanced tool capabilities such as automation triggers and agent invocation are not exposed over MCP today. For production use cases, MCP is reliable for read operations and simple write operations. Complex workflow automation via external MCP clients is better handled via 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
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 code they generate lands back in your 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 34 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.
Explore Taskade MCP setup in your workspace →
Browse the Community Gallery for engineering apps →
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 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 →