Integrations Everywhere: All Four Layers of Workspace DNA

Overview

Most platforms have an "integrations page." Taskade has integrations everywhere. Memory imports the world. Intelligence calls the world. Execution runs through the world. Interface ships to the world. Four layers, one workspace, every door open.

TL;DR: Taskade integrates with external systems at every layer of Workspace DNA. Projects (Memory) ingest 8+ file formats and pull from Google Drive, Dropbox, Box, OneDrive, plus 18+ competitor importers and bidirectional Google Calendar sync. AI Agents (Intelligence) call a large built-in toolkit, custom OpenAPI tools, and Enterprise BYOK keys for OpenAI, Anthropic, and Google, and the hosted MCP server lets external AI clients connect in on every paid plan, now editing tasks as well as reading them. Automations (Execution) fire on triggers and actions across five built-in step groups plus 100+ connected apps, plus the HTTP primitive, webhooks (Pro+), and AI primitives. Taskade Genesis Apps (Interface) publish to custom domains with built-in GenesisAuth sign-in and Stripe-backed App Kit paid apps. Bring your own keys, your own APIs, your own webhooks, your own auth.

The four-layer integration map

Every external system connects to Taskade through one of four layers. Pick the layer 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.

Layer 1: 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 OCR

Drop any of these formats into a project, an agent's reference library, or Media Files and Taskade ingests them into searchable Memory:

Every file lands in the multi-layer search index. Agents read them by reference. 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, so when the source updates, Taskade re-indexes.

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 native export and uses AI to convert pages and databases into the right Taskade primitives. See the full Import Guide for the supported sources.

Calendar feed and 2-way sync

Two calendar surfaces, different jobs:

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.

Multi-layer search

Every Memory artifact is searchable through a single index that combines:

• Full-text keyword search across all project content
• Semantic similarity for "find something like this"
• File-content OCR so scanned PDFs and image text count
• Permission-aware filtering so each searcher sees only what their workspace role allows

That last point is the moat. Search across competitors is either keyword-only or unaware of your team's permissions; Taskade does both layers in one query.

Layer 2: 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:

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

Custom tools (your APIs)

Agents define their own tools in three shapes:

1. OpenAPI Action: drop in an OpenAPI 3.x spec for any REST API; every operation becomes a callable tool with parameter validation.
2. Automation Action: wrap any automation action as an agent tool. The agent picks when to call it; the action runs durably.
3. Manual Trigger: expose an automation trigger as a tool the agent can fire on demand.

The result: any internal API, any third-party SaaS, any wrapped automation can become an agent capability without writing glue code.

The hosted MCP server

Taskade hosts an MCP server so external AI clients (Claude Desktop, Cursor, VS Code) connect into your workspace over the Model Context Protocol. Sign in once and the client can browse and inspect your projects, read tasks, and edit Taskade Genesis app source.

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 agent memory

Agents store their own memory as real Taskade Projects in a projects/memories/ folder. Inspectable, editable, governed by the same 7-tier RBAC as any other project. No black box.

Enterprise BYOK (v6.163)

Bring your own OpenAI, Anthropic, and Google keys, added per space under Connections → AI Model Keys. Your agents and your Ask AI and Generate with AI automation steps then run against your provider contracts and billing whenever they name a specific model. Taskade no longer mediates the API call. Key sovereignty, direct provider DPAs, per-tenant billing. See Bring Your Own AI Keys.

Plan-gated: BYOK is Enterprise-only on current plans. Some legacy lifetime and grandfathered plans also qualify.

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.

Layer 3: 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. The HTTP request action and Webhook Received trigger are your escape hatch for anything not yet on the list.

Some connectors go deep. Google Drive, Gmail, Slack, and Notion each ship a rich set of triggers and actions, covering 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 carries more surface area than any single SaaS connector:

AI as an automation step

AI is a first-class action inside any automation:

• Ask AI: generic AI call with optional structured JSON output (v6.162)
• Ask Agent: call any custom agent in your workspace
• Ask Agent Team: fan out to multiple agents and aggregate
• Categorize AI: preset-based classification for routing
• Generate AI / Respond AI: plain text generation
• Run Agent Command: invoke a specific agent skill

Media, utility, schedule steps

Beyond connectors, automations compose with built-in primitives:

HTTP and webhooks (your APIs)

Two escape hatches for anything not in the connector list:

• HTTP Request action: call any REST API with custom headers, auth, and body. Use it for internal services, niche SaaS, or quick prototypes.
• Webhook Received trigger: Taskade hosts a unique URL; any HTTP POST kicks off the flow. Bearer-token auth supported.

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

Durable execution

Every automation runs on a durable engine: failed steps retry automatically, partial state survives restarts, and webhooks are never silently dropped. You write the flow once; reliability is the platform's job.

Layer 4: Apps publish to the world

The Taskade Genesis App layer is where end users (strangers, customers, clients) touch your workspace. Seven first-class integration surfaces ship out of the box.

Custom domains with auto-SSL

Buy a domain through Taskade (.com, .org, .net, .app, .dev, .fyi) or bring your own via CNAME + TXT verification. Taskade handles SSL renewal, DNS, SPA routing, and password gating end-to-end. See Custom Domains.

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

GenesisAuth (v6.144+)

Drop-in email sign-in for any published Taskade Genesis app. Visitors sign in with their email right on your app's URL:

• No Taskade account needed for the people who use your app
• Secure, managed sessions you can revoke any time
• No auth server or backend to run

Short-lived sessions, rotated signing keys, no raw passwords ever stored. See GenesisAuth.

App Users (beta)

End-user management separate from your workspace team. Invite customers by email, tag them with roles you define, see every sign-in with provider and timestamp, revoke access in one click. App Users are not billed against your workspace seats. See App Users.

Personalize with currentUser

Once a user signs in, the currentUser object is available to every layer of the app. Use it in agent prompts, automation filters, and project queries to deliver per-visitor views:

• "Only show the Billing page to users tagged client."
• "Show each signed-in user only their own row from the Projects database."

Taskade EVE wires these checks into the app from plain English. No conditional-logic code.

App Kits

Package a published app as a frozen bundle (Projects + Agents + Automations + UI) and share with a clone link. Recipients materialize the full Workspace DNA in their own workspace. See Community Kits.

Paid App Kits via Stripe

Brand-new this week: sell an App Kit through Stripe. Set a price, buyers click "Clone," pay via Stripe checkout, the kit installs into their workspace.

Community Gallery and embeds

One-click publish to the Community Gallery (150,000+ apps live). When a Taskade Genesis app is embedded in another page, the surrounding navigation strips out automatically, so embeds feel native to the host site.

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 has at least one "bring your own" escape hatch.

The pattern: pick the layer that matches your job. Memory for data ingestion. Intelligence for agent capability. Execution for event-driven workflows. Interface for end-user-facing surfaces.

Plan-gating quick reference

Most integrations are available on every plan. A few are gated:

Cross-layer examples

The real power shows up when a single workflow crosses multiple layers. Three concrete patterns.

1. Webhook to AI triage to Slack

A four-step flow that touches three layers:

HTTP Webhook (Execution) →
  Ask AI structured output, JSON Schema (Execution + Intelligence) →
    Create Task in correct project (Memory) →
      Slack channel notification (Execution)

A vendor's system POSTs to your webhook URL. Taskade EVE classifies the payload into a category. The classified record lands in the right project. The team gets pinged in Slack. Durable execution means a failed Slack step retries without losing the record.

2. Client portal on your domain

A four-layer flow:

Project: client roster database (Memory) →
  Agent: sales assistant with custom tools (Intelligence) →
    Automation: weekly digest scheduled trigger (Execution) →
      Taskade Genesis App: client portal at portal.acme.com (Interface)

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 lets each client see only their own row via currentUser.email.

3. Sell an app kit via Stripe

A self-contained product:

Project templates (Memory) +
  Agent presets (Intelligence) +
    Automation flows (Execution) +
      Taskade Genesis App UI (Interface)
        → packaged as an App Kit
          → priced via Stripe checkout
            → buyer's workspace materializes the whole DNA

You build a CRM-in-a-box. Buyers click "Clone," pay through Stripe, the full Workspace DNA installs in their workspace. They get a working CRM. You get paid.

Related guides

• Workspace DNA. The four-layer architecture this article maps to.
• Agent Knowledge & Memory. How Projects feed Agent memory.
• Agent Tools. Full inventory of the built-in tools.
• Automations: The Execution Pillar. The canonical automations guide.
• Custom Domains. Brand your published Taskade Genesis app's URL.
• Watch: Connect Your Tools. A connection set up end to end, in under a minute.