TL;DR: Taskade plays both sides of MCP, as an MCP Server (Claude Desktop and Cursor read your workspace and edit your Genesis app source) and as an MCP Client (your agents call Notion, Linear, and external MCP servers). Taskade Genesis connects at https://www.taskade.com/mcp via OAuth2+PKCE. The hosted MCP server is available on every paid plan (Starter and up); the outbound MCP Client is Business+. 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 two-sided layer: external AI clients (Claude Desktop, Cursor) connect in as MCP clients to read Memory and edit your Genesis app source; your Taskade agents connect out as MCP clients to read and write Notion, Linear, and GitHub. Execution is every action that fires as a result: code written from your actual specs, Linear issues updated from sprint summaries, Notion pages synced from published articles. Every execution logs back to Memory, keeping the loop closed across your entire AI tool stack.
In April 2026, a newsletter from Taskade summarized the new agent capabilities simply: "Custom Tools via MCP, connect external APIs, works with Claude Code and Cursor."
That was the product description. The architectural significance is larger: Taskade now plays both sides of the Model Context Protocol stack. Claude Desktop and Cursor can read and write your Taskade workspace. Your Taskade agents can read and write Notion, Linear, and GitHub. The same AI workspace becomes both the destination for external AI tools and the origin of outbound AI actions.
This guide covers both directions: how to connect Claude Desktop and Cursor to Taskade as an MCP server, and how to configure Taskade agents to call external MCP servers. Full setup steps, use cases, and a cloneable workspace demo included.
MCP Architecture: Bidirectional Taskade ↔ AI Client
┌──────────────────────────────────────────────────────────────────┐
│ MCP: BIDIRECTIONAL TASKADE ↔ AI CLIENT │
├──────────────────────────────┬───────────────────────────────────┤
│ Taskade-as-Server │ Taskade-as-Client │
│ (External AI connects IN) │ (Taskade agents connect OUT) │
├──────────────────────────────┼───────────────────────────────────┤
│ Claude Desktop ──→ list_spaces Taskade Agent ──→ Notion │
│ Cursor IDE ──→ inspect_space Taskade Agent ──→ Linear │
│ VS Code ──→ write_file Taskade Agent ──→ GitHub │
│ Claude Code ──→ (3 hosted tools) Taskade Agent ──→ Slack │
│ │
│ Auth: OAuth2 + PKCE (scope "mcp") Auth: per-service OAuth │
│ Plan: Starter+ ($6/mo) Plan: Business+ ($40/mo) │
│ Status: GA (Starter+) Status: Business+ │
├──────────────────────────────┴───────────────────────────────────┤
│ VFS-backed: same Virtual File System Taskade EVE uses for app generation │
│ list_spaces · inspect_space = read-only · write_file = app/ only │
│ │
│ ▲ Memory → spaces, projects, sprint data, decision logs │
│ ■ Intelligence → read via inspect_space, edit app/ via write_file│
│ ● Execution → Linear synced · Notion updated · GitHub PR'd │
└──────────────────────────────────────────────────────────────────┘
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); projects, agents, and automations remain read-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 (Starter and up), the hosted MCP server is available on every paid plan; outbound MCP-as-Client requires Business+
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: Taskade Agents Calling External MCP Servers (Taskade as MCP Client)
The more powerful (and less discussed) direction: your Taskade agents calling external MCP servers.
When an AI agent in Taskade connects to an external MCP server, it gains the ability to read from and write to that external system as part of any workflow, without a human manually bridging the gap.
Tested external MCP servers: Notion, Linear. GitHub, Slack, and others are in testing.
Setting Up External MCP Connections
In your Taskade workspace, open an AI agent's settings:
- Go to Agent Settings → Custom Tools → MCP Connections
- Click "Add MCP Server"
- Enter the external server URL and authentication credentials
- Configure which tools the agent is authorized to use
Once connected, the agent can use those tools in any automation flow or conversation.
Use Case: Engineering Sprint Management
Agent: Sprint Manager (assigned to "Engineering" space)
MCP connections:
- Linear:
list_issues,update_issue,create_issue - GitHub:
list_prs,get_pr,add_comment
Workflow:
- Every Monday at 9am, the agent calls Linear via MCP to list all open issues tagged for the current sprint
- Agent cross-references with GitHub via MCP to check PR status for each issue
- Agent writes a sprint status summary to the Taskade Sprint Tracker project
- Automation triggers a Slack message with the summary to the engineering channel
The entire workflow runs without a human touching Linear, GitHub, or Taskade manually. The agent reads from both external systems, synthesizes the data, and writes the output to the appropriate workspace.
Live Demo, Content Calendar Planner:
Use Case: Content Operations with Notion
Agent: Content Sync Agent (assigned to "Marketing" space)
MCP connections:
- Notion:
query_database,update_page,create_page
Workflow:
- Taskade content calendar automation fires when a new article is ready for publish
- Content Sync Agent calls Notion via MCP to create a corresponding page in the content ops database
- Agent populates the Notion page with title, publish date, target keywords, and word count from Taskade
- When the article is marked "Published" in Taskade, agent updates the Notion page status via MCP
The result: your editorial calendar in Taskade and your content database in Notion stay in sync automatically, without either system being the "master" and without manual entry in both places.
The VFS Connection: Why Taskade MCP Works the Way It Does
Taskade's hosted MCP server exposes exactly three tools (list_spaces, inspect_space, write_file), all backed by the same Virtual File System (VFS) that Taskade EVE, the Taskade Genesis AI agent, uses internally for app generation.
This matters because VFS-backed operations are:
- Consistent: what Claude Desktop reads is the same representation Taskade EVE uses to build apps
- Contextual: the VFS includes structural relationships, which agents belong to which spaces, 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: MCP in Both Directions
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); projects, agents, and automations stay read-only - 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 MCP Server Security
When Taskade agents connect to external MCP servers (Notion, Linear, etc.):
- Each connection is independently authorized via that service's OAuth flow
- Credentials for external services are stored encrypted in your workspace
- The agent uses only the tools you have explicitly enabled for that connection
- External server actions are logged in your workspace automation history
MCP Use Cases: From Development to Content to Sales
For Engineering Teams
| Use Case | MCP Direction | Benefit |
|---|---|---|
| Cursor reads sprint tasks for context | Claude Desktop → Taskade | Code suggestions grounded in actual requirements |
| Agent syncs Linear issues to sprint board | Taskade → Linear | Single source of truth without manual updates |
| Agent pulls GitHub PR status to sprint report | Taskade → GitHub | Automated sprint velocity reports |
| Claude writes code output to Genesis app source | Claude Desktop → Taskade | Generated code lands directly in your app's app/ directory |
For Content Teams
| Use Case | MCP Direction | Benefit |
|---|---|---|
| Agent syncs published articles to Notion ops DB | Taskade → Notion | Editorial calendar stays in sync across tools |
| Claude reads content brief from Taskade | Claude Desktop → Taskade | AI writing grounded in your actual brief |
| Agent queries Notion research DB for article | Taskade → Notion | Research available to agents without manual import |
For Product Teams
| Use Case | MCP Direction | Benefit |
|---|---|---|
| Cursor reads product requirements for context | Cursor → Taskade | Feature code aligned with actual spec |
| Agent updates feature status in Linear | Taskade → Linear | Status updates flow from workspace to issue tracker |
| Agent creates Notion changelog from releases | Taskade → Notion | Automated changelog across systems |
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 (read-only via inspect_space) and write generated code into the Genesis app source (app/ directory via write_file).
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 (automation triggers, agent invocation via MCP) are in development. 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 the external MCP server is unavailable?
If an external MCP server (Notion, Linear) is unreachable during an agent workflow, Taskade handles the failure gracefully, the agent logs the error, the automation retries according to the configured retry policy, and the workspace continues operating. Taskade's reliable automation execution layer ensures external MCP failures 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: an AI agent can dynamically decide what to read or write based on the current task. MCP is more flexible (agents choose tools in context) but requires AI agent infrastructure. Zapier/Make are simpler for fixed trigger-action flows but cannot adapt to unstructured tasks. Taskade uses both: MCP for agent-driven context and API integrations for high-volume trigger-action automation.
Get Started with MCP and Taskade
The two-sided MCP architecture, Taskade as server and as client, positions your workspace at the center of your AI tool stack. Claude Desktop and Cursor read your actual requirements. Your agents write to Notion and Linear. The entire context loop closes automatically.
This is what "AI-connected workspace" means in practice: not one tool with AI features, but a system where every AI tool has access to every relevant piece of context, and every action flows back to the right place.
Workspace DNA: How MCP Extends the Intelligence Layer
Workspace DNA is the operating architecture that makes bidirectional 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 now spans two sides. External AI clients (Claude Desktop, Cursor) reason over your Memory to produce better code, documents, and analysis grounded in real requirements. Your Taskade agents connect out to external MCP servers (Notion, Linear, GitHub) to read data, take actions, and pull context automatically, 34 built-in tools plus MCP connections let each agent orchestrate across your entire tool stack without human relay.
- ● Execution (Automations): MCP actions are not one-off reads; they are the trigger layer for automated execution. An agent that reads Linear issues via MCP and writes a sprint summary to Taskade immediately triggers a Slack automation. An agent that reads a Notion research database via MCP and drafts an article logs the output back to the editorial queue project. Every execution feeds back to Memory, keeping context current across every tool in 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 →