Connect

Integrations Everywhere: Workspace DNA and the App on Top

Updated 2026-11-09·19 min read·View as Markdown

Overview

Most platforms have an "integrations page." Taskade has integrations everywhere. Memory imports the world. Intelligence calls the world. Execution runs through the world. The app on top ships to the world. One workspace, every door open.

TL;DR: Taskade connects to outside tools across Workspace DNA and the app on top. Projects import files and sync your calendar. AI agents use built-in tools and your own services, and outside AI apps connect in through the hosted MCP server. Automations run across 100+ connected apps. Taskade Genesis apps go live on your own domain with built-in sign-in.

The integration map

Every external system connects to Taskade through projects, agents, automations, or the app on top. Pick the part that matches your job. The others wire up automatically.

Read it as a loop, not a stack. The world feeds Memory. Memory powers Intelligence. Intelligence drives Execution. Execution writes back to Memory and surfaces through the Interface. Every integration plugs into one node and inherits the loop.

Projects import the world

Projects are where outside information becomes Taskade-native records: searchable, agent-readable, automation-ready. This is the layer most people first reach for.

File uploads and text recognition

Drop any of these formats into a project, an agent's reference library, or Media Files and Taskade turns them into searchable Memory. An agent's knowledge accepts every format below except images. Taskade also reads text out of scans and images for you, a step often called OCR:

Format Notes
.md, .txt Plain text, native
.docx Microsoft Word
.pptx PowerPoint slide decks
.xlsx, .csv Spreadsheets parse into table rows
.epub E-books, chapter-aware
.pdf Full text, plus text recognition for scanned pages
Images Text recognition reads the words in the picture. Not accepted as agent knowledge
YouTube links Auto-transcribed
Webpages Reads the live page. Refresh it any time

Taskade search finds every file. Agents read the files when they answer. Automations trigger on new uploads. Taskade Genesis apps can query them as live data sources.

Cloud-storage pickers

Inside the Agent Knowledge tab, the Add with picker pulls files directly from your existing storage:

  • Google Drive
  • Dropbox
  • Box
  • OneDrive

No re-upload. The link stays live. When the source file changes, Taskade reads the new version.

See Agent Knowledge & Memory for the full picker flow.

Competitor importers

Migrating in? Taskade ships purpose-built import flows for 18+ tools:

  • Project management: Notion, ClickUp, Monday, Asana, Trello, Todoist
  • Notes & wikis: Obsidian, Roam, Logseq, Evernote, OneNote, Bear, iA Writer
  • Outliners: Workflowy, Dynalist
  • Whiteboards: Miro, Whimsical
  • Docs: Google Docs

Each importer reads the source's own export file and uses AI to convert pages and databases into the right Taskade building blocks. See the full Import Guide for the supported sources.

Calendar feed and 2-way sync

Two calendar surfaces, different jobs:

Surface Direction Providers Plan
Calendar Feed Read-only subscription link (iCal) Apple, Google, Outlook All plans
Calendar Sync Two-way managed calendar Google only Paid workspaces

The feed lets any standards-compliant calendar app subscribe to a Taskade workspace. The two-way sync creates a managed "Taskade" calendar in Google Calendar so events created on either side stay aligned.

Taskade search finds anything in your projects and files. One search combines:

  • Full-text keyword search across all project content
  • Semantic similarity for "find something like this"
  • Text recognition inside files so words in scanned PDFs and images count
  • Permission-aware filtering so each searcher sees only what their workspace role allows

The last point keeps search safe for a team. A teammate never sees a result that their role does not allow.

AI Agents call the world

Agents are the layer that acts on external systems. They connect through five distinct mechanisms.

Built-in tools

Every Taskade agent ships with a default toolbox. The most-used:

Tool What it does
Web search Searches the live web and shows its sources
Read a web page Reads the text of a page
Summarize a web page Reads a web page and returns a short summary with its title and link
YouTube transcription Gets the transcript of a YouTube video
Image generation Makes images with frontier models
Files Reads, writes, and converts files
Workspace Manages projects, agents, automations, and media in your workspace
Run a script Runs a short script in a closed space that cannot touch anything else

See Agent Tools for the full inventory of built-in tools.

Custom tools (your own services)

An API is the doorway a piece of software opens so other software can talk to it. If a service you use has one, an agent can call it. Agents define their own tools in three shapes:

  1. OpenAPI Action: Paste in the OpenAPI 3.x description file for any web service. Every operation in that file becomes a tool the agent can call, with its inputs checked first.
  2. Automation Action: Wrap any automation action as an agent tool. The agent picks when to call it, and Taskade retries the action if a step fails.
  3. Manual Trigger: Expose an automation trigger as a tool the agent can fire on demand.

The result: any service your company runs, any third-party app, any wrapped automation can become an agent capability without writing connecting code.

The hosted MCP server

The Model Context Protocol (MCP) is a shared standard that lets AI apps reach your tools. Taskade hosts an MCP server so outside AI apps (Claude Desktop, Cursor, VS Code) connect into your workspace. Sign in once and the app can browse and inspect your projects, read tasks, and edit Taskade Genesis app files.

Plan availability: The hosted MCP server is available on every paid plan, Starter and up. It does not run on the Free plan.

The opposite direction, MCP-as-Client, lets Taskade call out to an external MCP server (Notion, Linear, a custom server). It runs through automations with the MCP Client connector, on every plan. An agent still cannot reach a server on its own, so it hands the call to an automation.

Persistent Taskade EVE memory

Taskade EVE keeps what it learns about your workspace in real Taskade projects that you can open and edit. Your account-wide preferences are stored separately. Edit or clear those preferences under Settings → Account. See Taskade EVE Memory for both kinds of memory.

Bring your own AI keys (BYOK)

Bring your own OpenAI, Anthropic, and Google keys, plus keys from more AI hosts such as xAI, Groq, DeepSeek, and Azure OpenAI. Add them per space under Connections → AI Model Keys. A key in the root workspace also serves the agents in its subspaces. Your agents and your Ask AI and Write with AI automation steps then run against your provider contracts and billing. This applies whenever they name a specific model. A new automation step offers TSK-Auto and the TSK tiers, and only some tiers run on your key. Each automation step on your key uses a fixed step fee in credits. Taskade EVE can build on your key too, when you pick a model under Your keys in its model menu. Taskade no longer sits in the middle of the model call. You keep control of your own keys, sign data processing agreements directly with the provider, and get billing per space. See Bring Your Own AI Keys.

Plan-gated: BYOK for OpenAI, Anthropic, and Google is available on Pro and up. A key from any other AI host needs Business and up. Some legacy lifetime and grandfathered plans also qualify. If a key fails, a workspace switch can move the reply to Taskade credits.

Public agents with chosen tools

Embed an agent publicly with one link. The owner picks which tools and which internal integrations are exposed to anonymous visitors. See Public Agents.

Automations do the work

Automations are where Taskade does work in the outside world. Triggers in, actions out, 100+ integrations on call.

Connected apps and services

Automations reach five built-in step groups plus 100+ connected apps. For a service that is not on the list yet, use the HTTP Request action or the Webhook Received trigger.

Type Examples
Connected apps Slack, Stripe, Salesforce, GitHub, Notion, ClickUp, Microsoft Outlook, plus the general-purpose web request and webhook steps
Built-in step groups Taskade, AI, Media, Schedule, Utilities

Some connectors go deep. Google Drive, Gmail, Slack, and Notion each ship many triggers and actions. They cover file events, message delivery, and database updates end to end.

Browse the full catalog with live trigger and action counts at taskade.com/integrations.

Taskade triggers and actions

The Taskade connector covers workspace events end to end, with triggers and actions for tasks, projects, comments, custom fields, and agents. It has more triggers and actions than any other single connector:

Triggers Actions
Task Added Create Project
Task Completed Add Task
Task Assigned Update Task
Task Moved Move Task Within Project
Task Due Assign Task / Unassign Task
New Due Date Mark Task Completed / Uncomplete Task
Due Date Removed Set / Clear Task Due Date
Task Custom Field Updated Update Custom Fields
New Comment Add Comment
Project Created Set Project Title / Date Range
Project Completed Tag / Untag / Pin / Unpin Project
Email Received (Mailhook) Archive / Unarchive Project
Task Manual Trigger Export Project / Get Project Info
Agent Public Chat Ended Find Task(s), Run Automation, Notify by Email, Attach File, Convert Media, Create From Template, Send Agent Chat Message

AI as an automation step

AI is a first-class action inside any automation:

  • Ask AI: asks AI a question and can return tidy, labeled fields instead of a paragraph, so later steps can use each field
  • Ask an agent: asks any custom agent in your workspace
  • Ask an agent team: asks several agents at one time and combines their answers
  • Categorize with AI: sorts each item into one of the categories that you set, so the automation can send it down the right path
  • Write with AI / Reply with AI: writes plain text
  • Run an agent command: runs one of the saved commands of an agent

Media, utility, schedule steps

Beyond connectors, automations combine with built-in building blocks:

Family Highlights
Media Summarize a web page, Read a web page, Search the web, Transcribe a YouTube video, Turn a file into text
Utilities Pull one field out of incoming data, format a date, find and replace text by pattern, calculate, look up a value
Schedule Every few minutes (paid plans), Every hour, Every day, Every week, Every month, Custom schedule
Control flow Branch (if/else), Loop (for each item in a list), Filter (stop or go), Delay (wait)

Web requests and webhooks (your own services)

Two steps cover any service that is not in the connector list:

  • HTTP Request action: call any web service directly, with your own sign-in details and your own data in the request. Use it for internal tools, niche apps, or quick tests.
  • Webhook Received trigger: a webhook is a private web address that another system can send a message to when something happens. Taskade gives you a unique one. Any message sent to it starts the automation. To protect it, set Verify requests on the trigger to a Bearer token, a Stripe signature, or an HMAC-SHA256 signature.

Plan-gated: The Webhook Received trigger requires the Pro plan and above.

Reliable runs

Every automation runs reliably. A failed step retries on its own, finished work is kept, and Taskade does not drop an incoming webhook message. You build the automation once, and Taskade keeps it running.

Apps publish to the world

The Taskade Genesis App layer is where the people who use your app (customers, clients, the public) reach your workspace. These surfaces come with every app.

Custom domains with automatic SSL

Buy a domain through Taskade (.com, .org, .net, .app, .dev, .fyi). Or bring your own, and add the two records that Taskade shows you at your domain provider. Taskade handles the security certificate (the padlock in the browser) and its renewal, the domain settings, and password protection. See Custom Domains.

Plan-gated: Custom domains require Pro plan and above.

Built-in app sign-in (GenesisAuth)

Every published Taskade Genesis app can have email sign-in. Visitors sign in with their email right on the address of your app:

  • No Taskade account needed for the people who use your app
  • Secure, managed sessions you can revoke any time
  • No sign-in server of your own to build or run

Sessions end on their own after a while, and Taskade never stores a password in plain text. See GenesisAuth.

App Users (beta)

End-user management separate from your workspace team. Add customers by email, make sign-up invite-only, ask for an emailed sign-in code, and disable or remove an account in one click. App Users are not billed against your workspace seats. See App Users.

Personalize the app for each visitor

After a visitor signs in, your app knows who they are. Use that in agent prompts, automation filters, and project lookups to show each visitor their own view:

  • "Only show the Billing page to signed-in people whose email is on the Clients list in my project."
  • "Match the signed-in email to the customer_email field, and show each person only the rows that match."

Taskade EVE adds these checks to the app from a plain-English request. You write no code. Sign-in confirms identity. You match records to the login, and you test with a second account before private data goes live.

App Kits

Package a published app (its projects, agents, automations, and screens) as one App Kit, and share it with a clone link. The people who clone it get the full Workspace DNA in their own workspace. See Community Kits.

Share an App Kit

Publish the kit to your profile or send the clone link. Anyone who clicks "Clone" installs the whole kit into their own workspace, subject to their plan limits per item.

Taskade App Factory and embeds

Publish to the Taskade App Factory in one click. When you embed a Taskade Genesis app in another page, Taskade hides its own menus, so the app looks like part of that page.

Password-protected apps

Lighter alternative to per-user identity. Share one password with all visitors. Good for client portals and demos that do not need individual accounts.

Bring your own: the BYO ladder

Every layer lets you bring at least one thing of your own.

Layer Bring your own Where to go
Projects Files in any format, scans included Upload directly or via Agent Knowledge
Projects Files from existing Drive / Dropbox / Box / OneDrive "Add with" picker in Knowledge tab
Projects Calendar events from Apple / Google / Outlook Calendar Feed
Agents Any web service as a tool OpenAPI 3.x description file in agent settings
Agents Your own AI app (Claude Desktop, Cursor, VS Code) MCP Server (every paid plan)
Agents and automations OpenAI / Anthropic / Google keys BYOK on Pro and up, under Connections
Agents Keys from other AI hosts, such as xAI, Groq, DeepSeek, or Azure OpenAI BYOK on Business and up, under Connections
Automations Any web address you can call HTTP Request action
Automations Inbound events from any system Webhook Received trigger (Pro+)
Automations Inbound email Mailhook (unique address, all plans)
Taskade Genesis Apps Built-in email sign-in for app users App sign-in (GenesisAuth)
Taskade Genesis Apps Custom domain you already own Custom Domains (Pro+)
Taskade Genesis Apps Public app page and clone link App Kits

The pattern: pick the layer that matches your job. Memory for bringing data in. Intelligence for agent capability. Execution for work that starts when an event happens. Interface for anything your customers see.

Plan-gating quick reference

Imports, calendar feeds, and the standard connectors run on every plan. Most third-party connectors need a paid plan:

Feature Free Starter Pro Business Max Enterprise
File imports ✓ ✓ ✓ ✓ ✓ ✓
Cloud-storage pickers ✓ ✓ ✓ ✓ ✓ ✓
Competitor importers ✓ ✓ ✓ ✓ ✓ ✓
Calendar Feed ✓ ✓ ✓ ✓ ✓ ✓
Calendar two-way Sync ✗ ✓ ✓ ✓ ✓ ✓
Built-in agent tools ✓ ✓ ✓ ✓ ✓ ✓
Custom OpenAPI tools (your own services) ✓ ✓ ✓ ✓ ✓ ✓
Hosted MCP server ✗ ✓ ✓ ✓ ✓ ✓
BYOK (your own AI keys) ✗ ✗ ✓ ✓ ✓ ✓
Standard connectors (HTTP Request, RSS, Pushover, MCP Client) ✓ ✓ ✓ ✓ ✓ ✓
Premium connectors (Slack, Gmail, Google Sheets, Notion, and more) ✗ ✓ ✓ ✓ ✓ ✓
Pro connectors (Figma, Attio, Pipedrive, and more) ✗ ✗ ✓ ✓ ✓ ✓
HTTP Request action ✓ ✓ ✓ ✓ ✓ ✓
Webhook Received trigger ✗ ✗ ✓ ✓ ✓ ✓
Custom domains ✗ ✗ ✓ ✓ ✓ ✓
App sign-in (GenesisAuth) ✓ ✓ ✓ ✓ ✓ ✓
App Users ✓ ✓ ✓ ✓ ✓ ✓
App Kit cloning ✓ ✓ ✓ ✓ ✓ ✓

Cross-layer examples

The best results come from one process that crosses multiple layers. Three concrete patterns.

1. Webhook to AI triage to Slack

A four-step automation that touches Memory, Intelligence, and Execution:

A system of a vendor sends a message to your webhook address. The Ask AI step reads the incoming data and sorts it into a category. The sorted record lands in the right project. The team gets a Slack message. If the Slack step fails, it retries, and the record stays safe.

2. Client portal on your domain

A setup that uses Workspace DNA and the app on top:

Each layer plays its role. Projects hold the client roster. The agent answers questions about it. The automation sends a weekly status digest. The portal shows each client their own row after you match the signed-in email to the client list and test it with a second account.

3. Share an app kit

A self-contained system:

You build a customer relationship management (CRM) system in a box. Recipients click "Clone" and the full Workspace DNA installs in their workspace. They get a working CRM on day one.

Was this helpful?