*/, {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify({
url: "https://api.example.com/v1/data",
method: "GET",
headers: {
// {{secret}} is the substitution token; which stored secret fills it
// is determined by a separate alias field, e.g. secretAlias: 'MY_API_KEY'
"Authorization": "Bearer {{secret}}"
},
secretAlias: "MY_API_KEY"
})
});
const data = await response.json();
```
At request time the proxy resolves `secretAlias` to the stored secret and replaces `{{secret}}` in the outbound request with the real credential value. The browser bundle only ever contains the alias string, not the credential itself.
{% hint style="info" %}
The exact proxy surface is managed by Genesis. You describe the integration you need in plain English and Genesis generates the appropriate outbound call β the `{{secret}}` substitution happens automatically, with the target secret selected via the alias you specify.
{% endhint %}
***
## Security Model
| Layer | What Taskade does |
| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Storage** | Secret values are encrypted at rest; the raw value is never returned to the client after saving |
| **Substitution** | `{{secret}}` replacement happens server-side inside the proxy (the alias field selects which stored secret is used), never in the browser bundle |
| **SSRF protection** | The proxy blocks requests to internal network ranges and loopback addresses (e.g., `169.254.x.x`, `10.x.x.x`, `127.0.0.1`); destination-host allowlisting is being rolled out |
| **Response scrubbing** | Sensitive upstream response headers (e.g., `Set-Cookie` from the external API) are stripped before the response reaches your app |
| **Audit scope** | Secret access is scoped to the space where the secret is defined; other spaces cannot reference it |
***
## Publish Guard
Before Genesis publishes or deploys your app, it scans the app source for patterns that look like hardcoded credentials (long random strings in assignment statements, common key-prefix patterns, etc.).
If a potential hardcoded secret is detected, **publishing is blocked** and Genesis surfaces a warning identifying the suspicious line. To resolve it:
1. Move the credential to **Settings β Secrets** with an appropriate alias.
2. Replace the hardcoded value in your source with `{{YOUR_ALIAS}}`.
3. Re-publish.
This guard runs on every publish attempt and cannot be bypassed β it is a safety rail, not an optional lint check.
***
## Best Practices
* **Use descriptive aliases** β `SENDGRID_API_KEY` is clearer than `KEY1` when you return to the project later.
* **One secret per credential** β avoid bundling multiple keys into a single secret value; granular secrets are easier to rotate.
* **Rotate regularly** β update the secret value in the vault; your app code references the alias and picks up the new value immediately.
* **Least privilege** β where the external API supports scoped tokens (read-only, single-resource, etc.), use the narrowest scope that your app requires.
* **Never log secret aliases in output** β even the alias name can hint at what services your app connects to.
# Run Your Business on Genesis
Build and run a real business on Taskade Genesis β an ops dashboard, a CRM, or a client portal β with logins and your own domain. No code, no sales call.
**Describe your business in plain English and get a real, running app β then put it on your own domain with logins and run your operation on it.** No code. No sales call.
Thousands of operators β consultants, clinics, realtors, agencies, construction and logistics teams β already run their day-to-day on a Taskade Genesis app. This track stitches the pieces into one path: **build β add your data β add logins β put it on your domain β go live.**
***
## Pick what you're building
{% hint style="info" %}
New to Taskade Genesis? Start with [Your first app in 5 minutes](/taskade-genesis/genesis/getting-started), then come back here to turn it into a business you run.
{% endhint %}
**Build your own, or start from a kit.** Describe your business and [build from scratch](https://www.taskade.com/create), or clone a ready-made app for free from the [community gallery](https://www.taskade.com/community) or [Taskade's official kits](https://www.taskade.com/user/taskade) and make it yours. Both paths lead to the same steps below.
| You want to⦠| Start here |
| --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| See the whole journey end to end | [From idea to live business β the 5 steps](/run-your-business-on-genesis/run-your-business/from-idea-to-live-business) |
| Give clients or members a private login | [Build a client or member portal](/run-your-business-on-genesis/run-your-business/build-a-client-portal) |
| Run internal operations with your team | [Build an internal ops dashboard](/run-your-business-on-genesis/run-your-business/build-an-ops-dashboard) |
| Add sign-in and roles to any app | [Add login and roles](/run-your-business-on-genesis/run-your-business/add-login-and-roles) |
| Launch to real users with confidence | [Is your app production-ready?](/run-your-business-on-genesis/run-your-business/go-live-checklist) |
***
## How the track fits together
{% stepper %}
{% step %}
#### Build it
Describe the app you want to Taskade Genesis and iterate until it works. β [Getting started](/taskade-genesis/genesis/getting-started)
{% endstep %}
{% step %}
#### Make it your system of record
Shape your data and views so the app holds the real records your business runs on. β [Projects & databases](/workspaces/workspaces/projects-databases)
{% endstep %}
{% step %}
#### Add logins and roles
Let the right people in β your team internally, or your clients externally β each seeing only what they should. β [Add login and roles](/run-your-business-on-genesis/run-your-business/add-login-and-roles)
{% endstep %}
{% step %}
#### Put it on your domain
Launch the app at your own web address with automatic HTTPS. β [Custom domains](/taskade-genesis/space-apps-guide/custom-domains)
{% endstep %}
{% step %}
#### Go live
Run the checklist, right-size your plan and credits, and launch. β [Go-live checklist](/run-your-business-on-genesis/run-your-business/go-live-checklist)
{% endstep %}
{% endstepper %}
## Next steps
* [From idea to live business β the 5 steps](/run-your-business-on-genesis/run-your-business/from-idea-to-live-business)
* [Build a client or member portal](/run-your-business-on-genesis/run-your-business/build-a-client-portal)
* [Build an internal ops dashboard](/run-your-business-on-genesis/run-your-business/build-an-ops-dashboard)
* **Operate your live app by talking to Claude** β read and update your app's data in plain English. See [Run your live app by talking to Claude](/developers/workspace-mcp/run-your-app-with-ai).
* [What your app will cost](/help/account-management/credits-and-billing)
* **Extend your live system:** read & write your data with [Workspace MCP](/developers/workspace-mcp), orchestrate agents and edit your app's code with the [Hosted Taskade MCP](/developers/workspace-mcp/genesis-app-mcp), or connect external tools with [MCP Connectors](/developers/mcp-connectors).
# From Idea to Live Business
Build a business app with no code and go live on Taskade Genesis in five steps: describe it, shape your data, add login, brand your domain, then launch.
You have a business problem and an idea for an app that fixes it. This guide is the spine: five steps that take you from a plain-English idea to a real, branded app your customers can sign in to and use. Each step links to a full guide when you want the detail.
The five steps form one path from idea to a live, branded app.
```mermaid
graph LR
A["Step 1
Describe your app
to Taskade Genesis"] --> B["Step 2
Shape data into a
system of record"]
B --> C["Step 3
Add login and roles"]
C --> D["Step 4
Put it on your
own domain"]
D --> E["Step 5
Right-size your plan
and go live"]
```
***
## Step 1 β Describe your app to Genesis
Start with the problem, not the software. Tell Taskade Genesis what you do, who will use the app, and what should happen when they use it. EVE turns that description into a working app β the screens, the data behind them, and the logic that connects them. This is where your idea becomes something you can click. You build by describing changes in plain English, so refining is just another sentence.
β Full guide: [Getting Started with Taskade Genesis](/taskade-genesis/genesis/getting-started)
## Step 2 β Shape your data into a system of record
Every real business app remembers things β customers, bookings, orders, requests. Taskade Genesis creates the databases your app needs automatically, and this is where you shape them: name your fields clearly, link related records, and choose the view (table, board, calendar, and more) that matches how you actually work. Get this right and your app stops being a form and becomes a single source of truth your whole business runs on.
β Full guide: [Projects & Databases](/workspaces/workspaces/projects-databases)
## Step 3 β Add login and roles
The moment real people use your app, you need accounts. GenesisAuth gives every app secure sign-in with no setup β you describe that users should log in, and the sign-in screen is built for you. From the App Users tab you invite people, suspend access, and decide who sees what. This is what turns a shared link into a real multi-user product.
β Full guide: [GenesisAuth](/community-and-sharing/community-and-sharing/genesis-auth)
## Step 4 β Put it on your own domain
A branded web address makes your app look like software you commissioned, not a tool you borrowed. Connect a domain like `app.yourcompany.com`, point one DNS record at Taskade, and your app goes live with automatic HTTPS β your customers see your brand, never a random link. This is the difference between a prototype and a product people trust with their data.
β Full guide: [Custom Domains & Branding](/taskade-genesis/space-apps-guide/custom-domains)
## Step 5 β Right-size your plan and go live
Your app runs on AI, and AI runs on credits. Before launch, match your plan and credit balance to how much you expect to use β turn on Auto Top-Up so a busy day never stops your workflows mid-task. Confirm billing is in order, then publish. You are live.
β Full guide: [Credits & Billing](/help/account-management/credits-and-billing)
***
{% hint style="success" %}
**Before you announce it, run the checklist.** Walk the [Go-Live Checklist](/run-your-business-on-genesis/run-your-business/go-live-checklist) to confirm sign-in, data, domain, and billing are all ready for real customers.
{% endhint %}
## Next steps
* [Go-Live Checklist](/run-your-business-on-genesis/run-your-business/go-live-checklist) β final pre-launch pass before you share the link
* [Add Login & Roles](/run-your-business-on-genesis/run-your-business/add-login-and-roles) β go deeper on accounts and access control
* [Getting Started with Taskade Genesis](/taskade-genesis/genesis/getting-started) β revisit Step 1 to refine your app
* [Custom Domains & Branding](/taskade-genesis/space-apps-guide/custom-domains) β polish your branded launch
* [Run your live app by talking to Claude](/developers/workspace-mcp/run-your-app-with-ai) β once you're live, read and update your app's data in plain English
# Build a Client or Member Portal
Build a client portal or member portal where each client logs in and sees only their own info β no code. Keywords: client portal, member portal, login, no-code.
**You describe the portal you want. Taskade Genesis builds it. Each client logs in and sees only their own record β their projects, their files, their status β and nothing belonging to anyone else.**
No code. No separate login service to wire up. No spreadsheets to share by hand. By the end of this guide you'll have a working, branded portal at your own web address that you can hand to your first client.
***
{% hint style="info" %}
**This works for any business.** A "client" can be whatever you serve β swap the examples to fit:
* **Consulting** β each client sees their project status, deliverables, and invoices.
* **Clinic / practice** β each patient sees their appointments, intake forms, and documents.
* **Course / membership** β each member sees their lessons, progress, and resources.
* **Agency** β each account sees their campaigns, assets, and reports.
{% endhint %}
***
{% stepper %}
{% step %}
### Describe the portal
Open Taskade Genesis and describe what you want in plain English β who logs in, what they see, and what stays private. Taskade Genesis turns that description into a working app with a database and screens already wired together.
Start with a prompt like this and edit the bracketed parts for your business:
```
Build a client portal for my consulting business. Each client signs in with
their own account and sees only their own dashboard: their active projects,
the documents I've shared with them, an invoice list, and a status update for
each project. Clients can never see other clients' information. I sign in as
the owner and can see and manage every client from one admin view.
```
The more specific you are about *what each client sees*, the better the first build. New to Taskade Genesis? Walk through [Getting Started](/taskade-genesis/genesis/getting-started) first.
{% endstep %}
{% step %}
### Give each client their own login
A portal needs real sign-in so the right person sees the right thing. When your prompt mentions per-client accounts, Taskade Genesis adds a secure login automatically β no auth provider to set up.
You manage everyone from the **App Users** tab: invite clients by email, suspend access when an engagement ends, and remove accounts you no longer need. See [GenesisAuth β add login & roles](/community-and-sharing/community-and-sharing/genesis-auth) for the full picture.
{% hint style="success" %}
If your first build didn't add sign-in, just tell Taskade Genesis *"add sign-in so each client has their own account"* while editing the app.
{% endhint %}
{% endstep %}
{% step %}
### Show each client only their record
This is what makes it a *portal* instead of a shared page: every client sees only their own data. Conceptually, each record in your portal is tied to the client it belongs to, and the login decides which records that person can open. Client A signs in and sees Client A's projects; Client B never sees them.
You don't configure this by hand β you describe it. Phrases like *"each client sees only their own projects and documents"* tell Taskade Genesis to scope the data per user. To shape what's stored and shown, see how [Projects & Databases](/workspaces/workspaces/projects-databases) hold your records, and how [GenesisAuth](/community-and-sharing/community-and-sharing/genesis-auth) ties each record to the signed-in client.
{% hint style="warning" %}
Always test isolation before going live: sign in as a test client and confirm you can't see anyone else's records.
{% endhint %}
{% endstep %}
{% step %}
### Put it on your domain
A portal at `portal.yourbrand.com` feels like software you built, not a generic link. Once your domain is connected, clients sign in and work entirely under your brand β they never see Taskade in the URL.
Follow [Custom Domains & Branding](/taskade-genesis/space-apps-guide/custom-domains) to connect a subdomain like `portal.yourbrand.com`, add your logo and colors, and turn on automatic HTTPS.
{% endstep %}
{% step %}
### Invite your first client
You're ready to go live. Open the **App Users** tab and invite your first client by email β they'll get a link, set a password, and land directly on their own dashboard.
Before you send invites, run the [Go-live checklist](/run-your-business-on-genesis/run-your-business/go-live-checklist) so logins, per-client access, and your domain are all confirmed. Then start small: invite one trusted client, watch them use it, and refine the wording or layout by describing the change to Taskade Genesis.
{% endstep %}
{% endstepper %}
***
## Next steps
* [Add login & roles](/run-your-business-on-genesis/run-your-business/add-login-and-roles) β set up sign-in and decide who can see and do what.
* [Go-live checklist](/run-your-business-on-genesis/run-your-business/go-live-checklist) β confirm access, branding, and your domain before inviting clients.
* [GenesisAuth](/community-and-sharing/community-and-sharing/genesis-auth) β manage clients in the App Users tab.
* [Custom Domains & Branding](/taskade-genesis/space-apps-guide/custom-domains) β host the portal at `portal.yourbrand.com`.
* [Getting Started with Taskade Genesis](/taskade-genesis/genesis/getting-started) β how describing an app turns into a working one.
# Build an Internal Ops Dashboard
Build an internal ops dashboard, CRM, or pipeline your team logs into β describe it to Taskade Genesis, connect live workspace data, and add logins.
You don't need a developer to give your team one place to run the day. Describe the board, pipeline, or tracker you wish you had, and Taskade Genesis builds it on top of your live workspace data. Your team logs in with the Taskade identity they already use, sees the same up-to-date picture you do, and gets a daily summary in Slack or email β without anyone touching a spreadsheet on the side.
This is the **internal** counterpart to a client portal. Here the people logging in are your own crew, dispatchers, project managers, or coordinators β not your customers.
{% stepper %}
{% step %}
### Describe your board or pipeline
Open Taskade Genesis and tell it, in plain English, what your team needs to see and do every day. Name the stages, the fields you track, and the views you want. Taskade Genesis turns that one description into a working app β the UI, the database behind it, and the structure to keep it organized.
```
I run field operations for a construction company and need my project
managers to track every active job from bid to close-out. Show jobs as a
board with columns for Bid, Scheduled, In Progress, Inspection, and Closed.
Each job has a site address, client name, assigned crew, start date,
target completion, and current status. Let managers drag jobs between
columns and add notes and photos. I want a dashboard view that shows how
many jobs sit in each stage so I can see where we're stuck at a glance.
```
Start with one workflow you already run on whiteboards or spreadsheets. You can refine wording, add fields, or change views later just by asking. For the full describe-and-build loop, see [Getting Started with Taskade Genesis](/taskade-genesis/genesis/getting-started).
{% endstep %}
{% step %}
### Connect live workspace data
The board Taskade Genesis builds isn't a static mockup β it's backed by a real project database that acts as your **system of record**. Every job, lead, or shipment is a live record your team reads and updates in real time, and the same data feeds your dashboards, agents, and automations.
That means there's no separate spreadsheet to reconcile. When a manager moves a job to "Inspection," the dashboard counts update instantly for everyone. To understand how projects work as live databases β fields, views, relationships, and permissions β see [Projects & Databases](/workspaces/workspaces/projects-databases).
{% endstep %}
{% step %}
### Let your team in with their existing Taskade identity
Because this is an internal tool, your team should sign in with the identity they already have. **Workspace members** use Workspace Single Sign-On β their existing Taskade credentials get them into the app with no second account to manage and no separate user directory to maintain.
This is the key distinction for an internal dashboard: you invite people to the **workspace**, and they reach the app through the identity they already use every day. Set who can view versus edit, and you control access from one place. See [GenesisAuth](/community-and-sharing/community-and-sharing/genesis-auth) for Workspace SSO, the App Users tab, and access control.
{% endstep %}
{% step %}
### Wire a daily digest
Give your team a heads-up without anyone having to open the app first thing. Add a scheduled automation that builds a short summary β open jobs, overdue items, what moved yesterday β and sends it to a Slack channel or by email every morning.
Describe it the same way you described the board: tell Taskade Genesis what to include and when to send it. The automation reads straight from your live project data, so the digest is always current. See [Automations](/automations/automation) to build the scheduled summary.
{% endstep %}
{% endstepper %}
{% hint style="info" %}
**Internal vs. external β pick the right access model.**
**Internal (this guide):** your team logs in with their **workspace identity** (Workspace SSO). Use this for ops dashboards, CRMs, and pipelines your own crew runs on.
**External:** clients and customers sign in as **App Users** β separate accounts scoped to the app, not members of your workspace. Use that model when you're building a client-facing portal. See [Build a client portal](/run-your-business-on-genesis/run-your-business/build-a-client-portal).
Same Taskade Genesis app, two different doors. Choose based on who's logging in.
{% endhint %}
## Next steps
* [Add login and roles](/run-your-business-on-genesis/run-your-business/add-login-and-roles) β control who can view versus edit your dashboard.
* [Go-live checklist](/run-your-business-on-genesis/run-your-business/go-live-checklist) β what to check before your team starts relying on it.
* [Build a client portal](/run-your-business-on-genesis/run-your-business/build-a-client-portal) β the external counterpart, for customers instead of your team.
# Add Login & Roles
Add secure sign-in and access control to your Taskade Genesis app so the right people see the right things β no code, no third-party auth provider.
Taskade Genesis apps can ship with real user accounts and secure sign-in built in, powered by [GenesisAuth](/community-and-sharing/community-and-sharing/genesis-auth). To add login, you don't configure anything β you describe the need when you build the app (for example, *"users can sign in to see their own dashboard"*), and Taskade Genesis wires up the sign-in component, session handling, and per-user data access automatically.
{% hint style="success" %}
**The short version:** Describe an app that needs accounts, and your app gets a working login screen. Then manage who gets in from the **App Users** tab in your app's settings.
{% endhint %}
***
## When to use what
GenesisAuth is part of a broader access-control story. Pick the control that matches who needs to get in and how locked-down it has to be. Every option below is no-code.
| Control | What it does | When to use |
| ----------------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------ |
| **GenesisAuth (App Users)** | Account-based sign-in for your app's end users | Any multi-user app β external clients, members, or customers |
| **Workspace SSO** | Lets your Taskade workspace members sign in with their existing identity | Internal tools for your own team |
| **Password-protected public links** | A single shared password on a link | A quick gated preview |
| **Private / Unlisted visibility** | Controls whether the app can be discovered | Non-indexed, share-by-link only |
| **Public agent tool opt-out** | Keeps sensitive tools workspace-only | Apps that publish an AI agent |
For external customers and members, reach for **App Users**. For your own staff, **Workspace SSO** means no second account to manage. For a fast, low-stakes gate, a **password-protected link** is enough.
{% hint style="info" %}
The **App Users** tab is currently in Beta and rolling out across paid plans.
{% endhint %}
***
## How to turn it on
You won't find a switch to flip β you ask for it in plain language.
1. In Taskade Genesis, describe an app that needs accounts. Include phrases like *"a client portal where each client has their own dashboard"* or *"a members-only knowledge base."*
2. Taskade Genesis generates the app **with the sign-in component already in place**.
3. Open your app's settings and go to the **App Users** tab to invite people, suspend access, or remove accounts.
If your first prompt didn't add login, you can ask Taskade Genesis to *"add sign-in for users"* later while editing the app.
For the full walkthrough β the App Users tab, Workspace SSO, custom-domain sign-in, and the security model β see the source page:
{% content-ref url="/pages/hKwzStqcwyuCZmgrLafr" %}
[GenesisAuth](/community-and-sharing/community-and-sharing/genesis-auth)
{% endcontent-ref %}
***
## Give each user only their own rows
For a client portal or member app, signed-in users usually shouldn't see each other's records. Turn on **Private per-user data** (row scoping) when you publish:
1. Open your app's **publish menu** and enable **Private per-user data**. (The option appears for apps built on the current app template with sign-in enabled; turning it on rebuilds and republishes the app.)
2. Pick β or add β a dedicated field on your project that stores each row's owner. Rows created **through the app** are tagged to the signed-in user automatically.
3. Publish. Each signed-in user now sees only their own rows. Rows with no value in the owner field are hidden from app users entirely β the safe default.
{% hint style="info" %}
Before you launch, sign in as a test user and confirm they see only their own records β this pairs with the [go-live checklist](/run-your-business-on-genesis/run-your-business/go-live-checklist) item on per-user data isolation. Data you add inside Taskade (rather than through the app) won't have an owner tag, so it stays hidden from app users until you assign one.
{% endhint %}
***
## Pair it with a custom domain
GenesisAuth works on apps hosted at your own web address with no extra setup. Combining sign-in with a [custom domain](/taskade-genesis/space-apps-guide/custom-domains) gives end users a fully branded, production-ready product.
{% hint style="warning" %}
**Never put real credentials in your app.** If your app calls an external service that needs an API key or token, store it in [App Secrets](/taskade-genesis/space-apps-guide/app-secrets) β a per-space vault β instead of writing it into your app. Secrets stay on the server and never ship in your exported app bundle.
{% endhint %}
***
## Next steps
* New to building? Start with [Getting Started](/taskade-genesis/genesis/getting-started).
* Read the full [GenesisAuth](/community-and-sharing/community-and-sharing/genesis-auth) reference for access control and security best practices.
* Connect a [custom domain](/taskade-genesis/space-apps-guide/custom-domains) for a branded, production sign-in.
* See login and roles in action: [Build a client portal](/run-your-business-on-genesis/run-your-business/build-a-client-portal) and [Build an ops dashboard](/run-your-business-on-genesis/run-your-business/build-an-ops-dashboard).
# Go-Live Checklist
A go-live checklist for launching your Taskade Genesis business app to real users β secrets, logins, your domain, and credits, all in one place.
You described an app, shaped your data, and it works. Before you put it in front of real customers or your team, run this checklist. Each item links to the page that covers it in full β work top to bottom and you'll launch with confidence.
***
### Security
* [ ] **Secrets are vaulted, not hardcoded.** Any API key, token, or password your app uses lives in the secret vault β never pasted into a prompt or page. β [App Secrets](/taskade-genesis/space-apps-guide/app-secrets)
* [ ] **The publish guard passed.** Taskade Genesis blocks publishing if it spots a hardcoded credential; resolve any warning before launch. β [App Secrets](/taskade-genesis/space-apps-guide/app-secrets)
### Access & data
* [ ] **Login and roles are configured.** The right people can sign in, and each role sees only what it should. β [Add login and roles](/run-your-business-on-genesis/run-your-business/add-login-and-roles)
* [ ] **Per-user data isolation is verified.** Sign in as a test client and confirm they can see only their own record β never anyone else's. β [Add login and roles](/run-your-business-on-genesis/run-your-business/add-login-and-roles)
### Domain & publishing
* [ ] **Your custom domain is live with HTTPS.** Your app loads at your own address with the padlock showing. β [Put your app on your own domain](/taskade-genesis/space-apps-guide/custom-domains)
* [ ] **Visibility and publish strategy are set correctly.** Public, unlisted, or private β match it to who should reach the app. β [Publishing & cloning](/community-and-sharing/community-and-sharing/publish-and-clone)
### Cost & reliability
* [ ] **Auto Top-Up is enabled.** A customer-facing agent should never hit an out-of-credits screen mid-session β set a top-up so credits replenish automatically. β [Credits & billing](/help/account-management/credits-and-billing)
### Final checks
* [ ] **Test data is purged.** Remove the dummy records you created while building.
* [ ] **A version snapshot is taken**, so you can roll back if a later change misbehaves. β [Publishing & cloning](/community-and-sharing/community-and-sharing/publish-and-clone)
***
{% hint style="success" %}
**You're ready to launch.** Every box checked means your app is secure, access-controlled, on your domain, and won't run out of credits in front of a customer.
{% endhint %}
## Next steps
* [From idea to live business β the 5 steps](/run-your-business-on-genesis/run-your-business/from-idea-to-live-business)
* [Add login and roles to your app](/run-your-business-on-genesis/run-your-business/add-login-and-roles)
* [Put your app on your own domain](/taskade-genesis/space-apps-guide/custom-domains)
# AI Features Overview
Deploy custom AI agents with persistent memory, knowledge, and tool access across your Taskade workspace β the intelligence layer behind every app and workflow.
AI features let you build agents that reason over your workspace, learn from your knowledge, use tools, and work together in teams.
## I want toβ¦
| I want to⦠| Go to |
| --------------------------------------- | ------------------------------------------------------------------------------- |
| Create my first agent | [AI Agents Getting Started](/ai-features/ai-features/ai-agents-getting-started) |
| Give an agent knowledge and memory | [Agent Knowledge & Memory](/ai-features/ai-features/agent-knowledge) |
| Let an agent use tools and take actions | [Tools for AI Agents](/ai-features/ai-features/agent-tools) |
| Build a team of agents | [AI Agent Teams](/ai-features/ai-features/agent-teams) |
| Run multiple agents together | [Multi-Agent Collaboration](/ai-features/ai-features/multi-agents) |
**Think. Learn. Adapt.** Taskade AI features form the living intelligence layer of Workspace DNA, creating systems that understand, evolve, and provide increasingly intelligent value with every interaction.
{% hint style="success" %}
**Living Intelligence Layer** β AI that doesn't just assist, but learns from your business, adapts to your needs, and continuously improves. Powered by EVE, your living AI companion.
{% endhint %}
## What is Living Intelligence?
Living Intelligence is the agent layer in Taskade. Itβs how your workspace can **reason**, **draft**, **classify**, and **take action** using context from your projects.
Canonical foundation: [Workspace DNA](/platform/workspace-dna).
### What you use it for
* **Customer-facing help**: answer questions, route requests, propose next steps.
* **Ops + admin**: summarize updates, draft emails, generate reports, fill data gaps.
* **Sales + marketing**: qualify leads, personalize outreach, reuse brand voice.
* **Research**: extract key points from docs, compare options, track decisions.
### Core building blocks
#### AI agents
Agents are persistent assistants. You can scope them to a workspace, project, or use case. Learn more about [Taskade AI Agents](https://www.taskade.com/agents).
Start here: [AI Agents Getting Started](/ai-features/ai-features/ai-agents-getting-started).
#### Knowledge (what agents learn from)
Most βsmartnessβ comes from the knowledge you give agents. That includes project data and uploaded docs.
Start here:
* [Workspace DNA](/platform/workspace-dna)
* [Agent Knowledge & Memory](https://www.taskade.com/learn/agents/knowledge)
#### Tools (what agents can do)
Tools let agents do more than write text. They can create tasks, call integrations, and move work forward.
Start here:
* [Integration Overview](/automations/automation/comprehensive-integration-guide)
* [Actions & Triggers](/automations/automation/actions)
### Getting started (fast)
1. Create one agent for one job.
2. Give it 2β3 knowledge sources.
3. Run it on real inputs.
4. Tighten prompts and add tools only if needed.
### Where it shows up
* In your workspace as an assistant.
* Inside Taskade Genesis apps as an AI layer.
* In automations as a decision-maker.
Next:
* Build apps with agents: [Living Systems That Transform Business](/taskade-genesis/genesis)
* Put actions on autopilot: [Living Motion Overview](/automations/automation)
## Next steps
* [AI Agents Getting Started](/ai-features/ai-features/ai-agents-getting-started) β create one agent for one job
* [Tools for AI Agents](/ai-features/ai-features/agent-tools) β let agents take action, not just write text
* [Multi-Agent Collaboration](/ai-features/ai-features/multi-agents) β coordinate agents on bigger work
* [taskade.com/community](https://www.taskade.com/community) β browse agent templates and get help
{% hint style="info" %}
This page stays overview-level. Model comparisons, tool catalogs, and deep agent training patterns live in the linked guides.
{% endhint %}
# AI Agents Getting Started
Create, train, and deploy Taskade AI agents that read your docs, answer questions, run tasks, and power multi-agent teams across your workspace.
Transform your workspace with smart AI assistants that understand your business and can handle tasks automatically!
## What are AI Agents?
AI Agents are specialized assistants designed to automate activities like research, data analysis, and content creation. Learn more about [Taskade AI Agents](https://www.taskade.com/agents) and what they can do for your team. Think of them as smart team members who:
* π§ **Learn your business** by reading your documents and projects
* π€ **Answer questions** about your work and processes
* β‘ **Take actions** like creating tasks, sending emails, or updating spreadsheets
* π **Work 24/7** without breaks, weekends, or vacations
* π― **Specialize in specific roles** like marketing, legal, customer service, or research
**Real example:** Your "Customer Service Agent" can instantly answer questions about your products, create support tickets, and even draft response emails - all based on your existing knowledge base.
### What Can AI Agents Help With?
| **Area** | **Tasks** |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| **Task Automation** | β’ Auto-categorize tasks
β’ Prioritize by keywords
β’ Estimate duration
β’ Recommend task owners
|
| **Knowledge Retrieval** | β’ Fetch relevant documents
β’ Answer team questions
β’ Recommend reading material
β’ Suggest internal resources
|
| **Feedback & Improvement** | β’ Collect and analyze feedback
β’ Offer improvement insights
β’ Benchmark against past projects
β’ Highlight success stories
|
| **Meetings** | β’ Summarize discussions
β’ Recommend next steps
β’ Extract action items
|
| **Creative Assistance** | β’ Offer writing/editing aid
β’ Generate content ideas
β’ Review and improve copy
|
## When Should You Create an AI Agent?
Create an agent if you:
β
**Repeat the same tasks** multiple times per week\
β
**Spend 2+ hours weekly** on similar activities\
β
**Answer the same questions** over and over\
β
**Need help** with research, writing, or analysis\
β
**Want to streamline** team processes
## Industry-Specific AI Agent Examples
### Legal Teams
**Custom AI Agents for Legal Practice:**
{% hint style="success" %}
Legal AI agents can automate document review, conduct legal research, and manage cases efficiently, saving lawyers significant time on routine tasks while maintaining accuracy and compliance.
{% endhint %}
**Legal Agent Capabilities:**
* **Document Review**: Analyze contracts, briefs, and legal documents for key clauses and potential issues
* **Legal Research**: Search through case law, statutes, and legal precedents
* **Case Management**: Track deadlines, court dates, and document filing requirements
* **Client Communication**: Draft responses to common legal inquiries
* **Compliance Monitoring**: Stay updated on regulatory changes and requirements
**Training Your Legal Agent:**
**Document Types to Include:**
* Legal case documents and court filings
* Legal research materials and annotations
* Statutes, regulations, and legislative history
* Citation guidelines and legal journal articles
* Argumentation and negotiation materials
* Precedent-setting case laws and historical documents
* Legal textbooks, treatises, and specialized databases
**Legal Agent Templates:**
* **π©ββοΈ Legal Advisor**: General legal guidance and document analysis
* **π Contract Reviewer**: Specialized in contract analysis and risk assessment
* **π Research Assistant**: Legal research and case law analysis
* **βοΈ Compliance Monitor**: Regulatory compliance and updates
### Healthcare Teams
**Medical AI Agents for Healthcare Professionals:**
**Healthcare Agent Capabilities:**
* **Patient Documentation**: Assist with medical record organization and analysis
* **Research Support**: Find latest medical research and treatment protocols
* **Compliance Assistance**: Help maintain HIPAA and regulatory compliance
* **Scheduling Optimization**: Coordinate appointments and resource allocation
### Marketing Teams
**Marketing AI Agents for Campaign Management:**
**Marketing Agent Capabilities:**
* **Content Creation**: Generate blog posts, social media content, and marketing copy
* **Campaign Analysis**: Analyze performance metrics and suggest optimizations
* **Audience Research**: Identify target demographics and market trends
* **Competitive Intelligence**: Monitor competitor activities and strategies
### Customer Service Teams
**Support AI Agents for Customer Experience:**
**Customer Service Agent Capabilities:**
* **Ticket Routing**: Automatically categorize and prioritize support requests
* **Knowledge Base**: Provide instant answers to common customer questions
* **Escalation Management**: Identify when to escalate issues to human agents
* **Customer Feedback**: Analyze feedback patterns and suggest improvements
## Create Your First AI Agent in 5 Steps
### Step 1: Go to the Agents Tab
1. Open your Taskade workspace
2. Click the **π€ Agents** tab at the top
3. Click **β Create agent**
### Step 2: Choose How to Create Your Agent
Pick the best option for you:
**π― Describe What You Need** (Recommended for beginners)
* Simply tell Taskade what you want your assistant to do
* We'll build it automatically for you
* Works great for common business tasks
**π οΈ Build It Yourself**
* Create a custom assistant with specific abilities
* You decide exactly how it behaves and responds
* Best when you have unique requirements
**π Pick from Ready-Made Templates**
* Choose from assistants for Marketing, Support, HR, and more
* They're ready to work immediately
* You can customize them anytime
**π₯ Use Community Templates**
* Browse assistants created by other businesses
* Copy the ones that work for your needs
* Learn from successful setups
### Step 3: Tell Your Assistant What to Do
Give your AI assistant a clear role and personality - just like hiring a new team member:
**Name:** Make it memorable and relevant\
*Examples: "Sarah - Customer Success", "Marketing Mike", "Data Dave"*
**Description:** Explain what your agent does\
*Example: "You are a customer success specialist who helps clients get the most value from our product. You're friendly, knowledgeable, and always focused on solving problems."*
**Tone:** Choose how your agent should communicate
* Friendly and casual
* Professional and formal
* Creative and inspiring
* Direct and efficient
### Step 4: Train Your Agent with Knowledge
Make your agent smart by giving it information:
**π Upload Documents**
* Drag and drop PDFs, Word docs, spreadsheets
* Include product manuals, processes, FAQs
* Add training materials and guidelines
**π Add Websites**
* Your company website and blog
* Competitor information
* Industry resources and news
**π Connect Projects**
* Link existing Taskade projects as knowledge
* Agent learns from your current work
* Stays updated as projects change
**π₯ YouTube Videos**
* Training videos and tutorials
* Product demos and presentations
* Industry webinars and conferences
### Step 4.5: Choose Your AI Model
Taskade's model picker is powered by **TSK-1**, the intelligence layer that auto-routes every request to the right capability tier. You pick what you need the agent to do; TSK-1 handles which model executes it:
| Tier | When to use it |
| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| **Auto** (recommended) | TSK-1 picks the right tier per request β fast when you need speed, deep when you need reasoning. New agents default to Auto on every plan |
| **Instant** | Fast edits, simple completions, quick lookups |
| **Standard** | Everyday work β balanced speed and reasoning |
| **Thinking** | Planning, creation, multi-step reasoning |
| **Reasoning** | Complex systems, deep analysis, multi-agent coordination |
{% hint style="info" %}
**Vendor-agnostic.** TSK-1 runs on the latest frontier models. The tier describes what the system is good at, not which provider powers it β providers may change. Agents pinned to a custom model (Max and Enterprise plans) bypass TSK-1 routing. See [TSK-1 Model Tiers](/ai-features/ai-features/tsk-1-model-tiers) for the full reference.
{% endhint %}
## Understanding Agent Knowledge & Memory
Your agent's knowledge is what makes it truly powerful for your business. This is the foundation that powers Taskade Genesis apps - your workspace's living DNA.
### Types of Agent Memory
#### **Session Memory**
* Remembers conversation context during a chat
* Maintains topic continuity
* Resets when conversation ends
#### **Knowledge Memory**
* Permanent information from uploaded documents
* Your business-specific data and processes
* Forms the core intelligence for Genesis apps
#### **Project Memory**
* Live connection to your workspace projects
* Updates automatically as your data changes
* Powers the "living DNA" that makes each Genesis app unique
### Advanced Knowledge Training
#### **Bulk Training**
Upload multiple knowledge sources at once:
* Multiple files simultaneously
* Several web links in one batch
* Connect multiple projects together
* Perfect for comprehensive agent training
#### **Knowledge Formats Supported**
| **File Types** | **Web Resources** |
| ------------------------- | --------------------- |
| π .pdf, .docx, .txt, .md | π₯ YouTube videos |
| π .xlsx, .csv | π° Blog articles |
| π .pptx | π¦ Social media posts |
| π .epub | π° News websites |
#### **Knowledge Management Best Practices**
* **Review sources** regularly for relevance
* **Update documents** when business information changes
* **Remove outdated** resources to maintain accuracy
* **Test knowledge** by asking your agent questions
* **Monitor performance** and refine training data
### Step 5: Create Custom Commands
Give your agent specific skills with custom commands:
**Examples for a Sales Agent:**
* `/qualify-lead` - Analyze if a prospect is worth pursuing
* `/write-proposal` - Generate a custom proposal
* `/follow-up` - Create follow-up email sequences
**Examples for a Support Agent:**
* `/troubleshoot` - Help diagnose customer problems
* `/escalate` - Determine when to involve a human
* `/knowledge-search` - Find relevant help articles
## Popular Agent Types & Examples
### Marketing Agent
**What it does:** Content creation, campaign ideas, market research\
**Sample prompt:** "Create a social media post about our new product launch"\
**Best for:** Content teams, social media managers, small businesses
### Customer Support Agent
**What it does:** Answer questions, troubleshoot issues, route tickets\
**Sample prompt:** "A customer can't log into their account. What should I tell them?"\
**Best for:** Support teams, customer success, help desks
### Data Analysis Agent
**What it does:** Interpret data, create reports, find insights\
**Sample prompt:** "Analyze this month's sales data and highlight key trends"\
**Best for:** Analytics teams, managers, business owners
### Content Writing Agent
**What it does:** Blog posts, emails, documentation, copywriting\
**Sample prompt:** "Write a blog post about the benefits of remote work"\
**Best for:** Content creators, marketers, communications teams
### Research Agent
**What it does:** Gather information, summarize findings, competitive analysis\
**Sample prompt:** "Research the top 5 competitors in the project management space"\
**Best for:** Strategy teams, consultants, analysts
## Using Your AI Agent
### Method 1: Agent Chat
1. Go to the **Agents** tab
2. Select your agent
3. Click **β New chat**
4. Start asking questions or giving tasks
### Method 2: Project Integration
1. Open any project
2. Click the chat icon (π¬) at the top right
3. Select your agent from the dropdown
4. Get help with that specific project
### Method 3: Quick Commands
1. In any project, type **/** followed by your command name
2. Example: `/write-summary` or `/analyze-data`
3. Press Enter to execute
### Method 4: Agent Sidebar
1. Click the **β Manage agents** button
2. Star your favorite agents
3. Access them quickly from the right sidebar
## **Enhanced File Attachments**
Taskade EVE conversations now support rich file interactions with complete visibility and context.
### **Drag & Drop File Magic**
Simply drag any file directly into your EVE chat:
* **Images**: JPG, PNG, GIF, WebP - EVE analyzes visual content
* **Documents**: PDF, DOC, TXT - EVE reads and processes text
* **Spreadsheets**: CSV, Excel - EVE analyzes data and creates insights
* **Code Files**: Python, JavaScript, etc. - EVE reviews and suggests improvements
### **Visible File Context**
Files now appear directly alongside your messages instead of being hidden:
* **Chronological Organization**: See exactly when each file was shared
* **Visual Thumbnails**: Quick preview of images and documents
* **File Status Indicators**: Clear confirmation when files are processed
* **Conversation Flow**: Files integrate naturally with your discussion
### **Professional Use Cases**
**Document Analysis:**
```
You: [Attach quarterly_report.pdf] "Summarize the key findings and create action items"
EVE: "I've analyzed your Q3 report. Here are the 5 key findings..."
```
**Image Processing:**
```
You: [Attach screenshot.png] "What's wrong with this UI design?"
EVE: "Looking at your interface, I notice 3 usability issues..."
```
**Data Insights:**
```
You: [Attach sales_data.csv] "What trends do you see in this data?"
EVE: "Analyzing your sales data, I found these patterns..."
```
**Code Review:**
```
You: [Attach app.py] "Review this code for security issues"
EVE: "I've reviewed your Python code. Here are potential security concerns..."
```
### **File Management Features**
* **Rename Conversations**: Turn "Chat with EVE" into "Q3 Report Analysis"
* **File History**: Access previously shared files from conversation history
* **Cross-Reference**: EVE remembers files from earlier in the conversation
* **Batch Processing**: Upload multiple related files for comprehensive analysis
## Advanced Features
### Agent Tools
Give your agents superpowers by enabling tools:
**π Taskade Tools** - Create tasks, update projects, manage data\
**π Web Search** - Find real-time information online\
**π§ Email Integration** - Send emails through Gmail\
**π¬ Communication** - Post to Slack, Teams, Discord\
**π Data Tools** - Work with Google Sheets, databases\
**π Automation** - Trigger workflows and processes
### Multi-Agent Teams (Advanced)
{% hint style="success" %}
Multi-Agent Teams deploy personalized AI assistants that work concurrently on multiple tasks in the background, allowing you to focus on strategic work while your AI team handles the details.
{% endhint %}
#### What Are Multi-Agent Teams?
Multi-agents are an evolution of Taskade's agentic workflow designed to:
* **Work concurrently** on multiple tasks simultaneously
* **Execute in the background** while you focus on other priorities
* **Collaborate intelligently** with each agent bringing specialized expertise
* **Learn your preferences** and adapt to your communication style
* **Maintain context** across complex, multi-step workflows
#### Setting Up Your Multi-Agent Team
**Method 1: Build from Existing Agents**
1. Navigate to the **π€ Agents** tab in your workspace
2. Select multiple existing agents with complementary skills
3. Use the **Team Builder** to combine them into a cohesive unit
4. Configure team communication and collaboration rules
**Method 2: Create New Team from Templates**
1. Go to **AI Teams** section
2. Click **β Create Team** β **From Template**
3. Choose from pre-built team configurations:
* **Marketing Team**: Content + Social Media + Analytics agents
* **Customer Success Team**: Support + Documentation + Training agents
* **Product Development Team**: Research + Design + Testing agents
* **Operations Team**: Logistics + Communication + Reporting agents
**Method 3: Custom Team Creation**
1. Start with the **AI Team Generator** (see below)
2. Describe your ideal team composition and goals
3. Let AI automatically configure specialized roles and behaviors
4. Fine-tune the team based on your specific requirements
#### Using Multi-Agent Teams in Projects
**Option 1: Agent Sidebar Integration**
* Access your multi-agent team through the persistent agent sidebar
* Agents work in the background with real-time updates
* Pre-trained on your knowledge base and third-party integrations
* Quick access without leaving your current project context
**Option 2: Bulk Task Assignment**
* Assign multiple tasks to your agent team simultaneously
* Each agent handles tasks within their area of expertise
* Automatic task distribution and progress tracking
* Consolidated reporting on team performance
**Option 3: Conversational Collaboration**
* Chat with your entire agent team as a unified group
* Agents collaborate on complex problems and provide comprehensive solutions
* Shared conversation history for context and continuity
* Team members can participate alongside AI agents
#### Advanced Multi-Agent Features
**Memory and Context Management**
* **Short-term memory** for immediate conversation context
* **Long-term memory** for persistent knowledge and preferences
* **Cross-agent knowledge sharing** for improved collaboration
* **Conversation history** for iteration and refinement
**Iterative Output Development**
* Browse complete conversation histories
* Refine and improve outputs through multiple iterations
* Learn from previous interactions and feedback
* Build upon successful approaches and templates
**Team Communication and Sharing**
* Shared agent chats for team-wide collaboration
* Real-time collaboration on problem-solving
* Collective brainstorming and idea generation
* Distributed AI insights accessible to all team members
#### Managing Multi-Agent Teams
**Copy and Duplicate Teams**
* Save successful team configurations as templates
* Duplicate teams for similar projects or client work
* Share team setups across workspaces and organizations
* Version control for team configuration changes
**Sharing and Collaboration**
* Share agent teams with team members and stakeholders
* Granular permission controls for team access
* Public sharing options for community contributions
* Template marketplace for proven team configurations
#### Popular Multi-Agent Team Examples
| **Team Type** | **Agent Composition** | **Use Cases** |
| ------------------------------- | ----------------------------------------------------------------- | ---------------------------------------------------------------- |
| **Content Marketing Team** | Content Strategist + SEO Specialist + Social Media Manager | Blog posts, social campaigns, content calendars |
| **Customer Success Team** | Support Agent + Documentation Specialist + Training Coordinator | Onboarding, support tickets, knowledge base |
| **Product Launch Team** | Market Researcher + Copywriter + Analytics Expert | Product announcements, launch campaigns, performance tracking |
| **Research & Development Team** | Data Analyst + Technical Writer + Innovation Specialist | Competitive analysis, technical documentation, trend reports |
| **Operations Team** | Logistics Coordinator + Communication Manager + Reporting Analyst | Process optimization, team communication, performance dashboards |
### Human in the Loop Controls
For sensitive operations, multi-agent teams incorporate human oversight:
* **Action Approval**: Agents request permission before critical actions
* **Escalation Protocols**: Automatic human involvement for high-impact decisions
* **Audit Trails**: Complete logging of all agent actions and approvals
* **Override Capabilities**: Human ability to modify or stop agent processes
## Agent Tools & Integrations
### Enable Agent Tools
Agent Tools extend your multi-agent teams' capabilities by connecting to external services:
**Taskade Tools** - Create projects, update tasks, manage data **Web Search** - Find real-time information online **Email Integration** - Send emails through Gmail **Communication** - Post to Slack, Teams, Discord **Data Tools** - Work with Google Sheets, databases **Automation** - Trigger workflows and processes
## Best Practices
### Writing Good Prompts
β
**Be specific:** "Write a welcome email for new customers" vs "Write an email"\
β
**Give context:** Include relevant background information\
β
**Set expectations:** Explain the tone, length, and format you want\
β
**Provide examples:** Show the agent what good output looks like
### Training Your Agent
β
**Start with quality content** - Upload your best documents first\
β
**Update regularly** - Keep knowledge current and relevant\
β
**Test thoroughly** - Try different questions to ensure good responses\
β
**Iterate and improve** - Refine based on real usage
### Managing Multiple Agents
β
**Specialize agents** - Give each one a clear, focused role\
β
**Use descriptive names** - Make it easy to pick the right agent\
β
**Organize by function** - Group similar agents together\
β
**Share successful agents** - Let teammates copy your best configurations
## Troubleshooting
### Agent Giving Wrong Answers?
β
Check if it has the right knowledge documents\
β
Make sure information is up-to-date\
β
Improve your questions - be more specific\
β
Add more training examples to the knowledge base
### Agent Not Understanding Questions?
β
Rephrase your question more clearly\
β
Provide more context about what you need\
β
Check if the agent has relevant knowledge about the topic\
β
Try breaking complex questions into smaller parts
### Agent Actions Not Working?
β
Verify tool permissions are enabled\
β
Check if external services (Gmail, Slack) are connected\
β
Make sure you approved any required actions\
β
Look for error messages in the agent chat
## Next Steps
Ready to build your AI team?
1. **Start with one agent** - Pick your biggest time drain
2. **Train it well** - Upload quality knowledge and test thoroughly
3. **Use it daily** - The more you use it, the more time you save
4. **Expand gradually** - Add more agents as you see value
**Need inspiration?**
* [Browse the AI Agent Gallery](https://taskade.com/agents) for community examples
* [Watch tutorial videos](https://youtube.com/taskade) for step-by-step guides
* [Join our community](https://taskade.com/community) to share and learn
## Taking It Further
### **Build Without Permission**
You don't need permission to start. Not to ship. Not to define the system.
Your AI agents are just the beginning. Transform them into complete business applications with Genesis - the HyperCard moment for the AI era.
[**Read the Manifesto β**](https://www.taskade.com/blog/build-without-permission) - Build Without Permission
### **Build Genesis Apps with Your Agents**
Transform your AI agents into complete business applications. One prompt = one app. Your workspace = the backend. Your agents = the team.
* [**Genesis Getting Started β**](/taskade-genesis/genesis/getting-started) - Build your first app in 5 minutes
* [**Genesis Examples β**](/taskade-genesis/genesis/examples-and-templates) - See what others have built
### **Connect Agents to Automations**
Make your agents work automatically:
* [**Automation Getting Started β**](/automations/automation) - Put agents on autopilot
* [**Integration Guide β**](/automations/automation/integrations) - Connect to 100+ services
#### **Build Agent-Centric Automations**
Create automation workflows with your AI agents at the center:
**Access Agent Automation:**
1. Navigate to the **Agents** tab in your workspace/folder
2. Select an existing agent or create a new one
3. Click **Edit Agent** in the top-right corner
4. Go to the **Automation** tab on the left sidebar
**Create Agent Automation Flow:**
1. **Choose a connector** from available automation triggers
2. **Configure the trigger** to initiate your workflow
3. **Set up your agent** as the central processing component
4. **Add additional actions** before or after agent processing
5. **Test and deploy** your agent automation
**Supported Triggers for Agent Automations:**
* Task creation, updates, and completion events
* Project and folder activity triggers
* External service integrations (Gmail, Slack, etc.)
* Time-based and scheduled triggers
* Custom webhook and API triggers
**Agent Automation Benefits:**
* **Centralized Intelligence**: AI agents process and respond to complex scenarios
* **Seamless Integration**: Connect AI capabilities directly to business workflows
* **Autonomous Operation**: Agents handle sequences of tasks without manual intervention
* **Contextual Processing**: Maintain conversation context and memory across interactions
* **Scalable Automation**: Deploy intelligent workflows across multiple use cases
### **Advanced Knowledge Management**
Supercharge your agents with better knowledge:
* [**Knowledge Management Guide β**](/workspaces/workspaces/knowledge-management) - Organize information effectively
* [**Project Views β**](/workspaces/workspaces/project-views) - Structure data for AI understanding
## Advanced Agent Features
### **Command Modes: How Your Agent Thinks**
Command modes dictate how your AI agents approach tasks - whether by following specific instructions or by autonomously setting goals and working towards them.
#### **Available Command Modes**
| Mode | Description | Best For | Example |
| --------------------- | ------------------------------------------- | ---------------------------------- | ----------------------------------------------------------- |
| **Default Mode** | Follows specific instructions directly | Simple, straightforward tasks | "Write an email to customer about order delay" |
| **Plan & Execute V1** | Creates a plan, then executes step by step | Complex multi-step tasks | "Increase sales revenue" β Agent creates strategy plan |
| **Plan & Execute V2** | Advanced planning with iterative refinement | Complex goals requiring adaptation | "Improve team productivity" β Agent analyzes, plans, adapts |
#### **When to Use Plan & Execute Modes**
**β
Use Plan & Execute for:**
* Complex business problems without clear solutions
* Goals that require research and analysis
* Multi-step processes that need coordination
* Strategic planning and decision-making
**β Use Default Mode for:**
* Simple, direct tasks with clear instructions
* Quick responses and straightforward actions
* Tasks where you want specific output format
* Routine operations with established procedures
#### **Plan & Execute Examples**
**Example 1 - Specific Goal:**
```
Input: "I need strategies to increase sales revenue."
Agent Process:
1. Analyzes current sales data and trends
2. Researches market opportunities
3. Creates comprehensive strategy plan
4. Provides actionable recommendations
```
**Example 2 - Problem Statement:**
```
Input: "Our sales are declining."
Agent Process:
1. Investigates potential causes
2. Analyzes market conditions and competition
3. Develops diagnostic framework
4. Suggests targeted solutions
```
**Example 3 - Improvement Goal:**
```
Input: "I need advice on employee productivity improvement."
Agent Process:
1. Assesses current productivity metrics
2. Identifies bottlenecks and challenges
3. Researches best practices and solutions
4. Creates implementation roadmap
```
#### **Configuring Command Modes**
1. **Edit your agent** and go to the **Commands** tab
2. **Select a command** you want to modify
3. **Choose the command mode** from the dropdown
4. **Test the command** with sample input
5. **Adjust as needed** based on results
### **Bulk AI Commands: Process Multiple Tasks at Once**
Apply AI commands to multiple tasks simultaneously for efficient batch processing.
#### **How Bulk Commands Work**
1. **Select multiple tasks** in your project (hold Ctrl/Cmd while clicking)
2. **Right-click** or use the AI assistant panel
3. **Choose a bulk command** from the available options
4. **AI processes all selected tasks** with the same command
5. **Review and refine** results as needed
#### **Available Bulk AI Commands**
| Command | Action | Best For | Example |
| ------------------------------- | ------------------------------------- | -------------------------------------- | -------------------------------------------- |
| **πͺ Research** | Search the web to learn about topics | Market research, fact-checking | Research competitors for each product |
| **πͺ SEO** | Fetch top Google Search results | Content optimization, keyword research | Find SEO keywords for blog topics |
| **π Summarize** | Shrink down long discussions or notes | Meeting notes, document reviews | Summarize customer feedback responses |
| **π€ Turn into Action Items** | Convert ideas into actionable steps | Project planning, brainstorming | Turn feature requests into development tasks |
| **π‘ Prioritize** | Prioritize tasks based on importance | Task management, sprint planning | Rank support tickets by urgency |
| **π΄ Continue Writing** | Expand on existing content | Content creation, documentation | Expand product descriptions |
| **βͺοΈ Brainstorm** | Develop ideas in seconds | Creative projects, problem-solving | Generate marketing campaign ideas |
| **π΅ Rewrite** | Refine words for clarity and impact | Content editing, communication | Improve email templates |
| **π’ Outline** | Turn ideas into structured plans | Project planning, content strategy | Create article outlines from topics |
| **π₯ Fix Spelling and Grammar** | Edit out mistakes | Content review, documentation | Clean up imported content |
#### **Custom Agent Bulk Commands**
You can also use your custom AI agent commands with multiple tasks:
1. **Create custom commands** in your agent settings
2. **Select multiple tasks** that need the same processing
3. **Choose your custom agent command** from the bulk options
4. **AI applies your specialized command** to all selected tasks
**Example Use Cases:**
* **Sales Agent**: Qualify multiple leads simultaneously
* **Content Agent**: Generate social media posts for multiple products
* **Support Agent**: Categorize multiple customer inquiries
* **Research Agent**: Analyze multiple competitor websites
#### **Bulk Command Best Practices**
**β
Do:**
* Group similar tasks for bulk processing
* Review results and refine as needed
* Use consistent formatting across tasks
* Test commands on small batches first
**β Don't:**
* Mix different task types in one bulk operation
* Apply complex commands to too many tasks at once
* Skip reviewing AI-generated results
* Use bulk commands for tasks requiring individual attention
***
## **Mobile Agent Development**
Build and train AI agents directly from your mobile device, making agent development truly accessible anywhere.
### **Mobile Agent Creation**
| **Feature** | **Capability** | **Use Case** |
| --------------------------- | ---------------------------------- | --------------------------------- |
| **Quick Agent Setup** | Create agents with voice prompts | Build agents while commuting |
| **Mobile Knowledge Upload** | Add photos, documents, voice memos | Train agents with real-world data |
| **Agent Testing** | Test agent responses on mobile | Validate agent behavior instantly |
| **Mobile Commands** | Create custom commands via touch | Build agent tools on the go |
### **Mobile-Specific Agent Tools**
| **Tool** | **Mobile Advantage** | **Business Impact** |
| ---------------------- | ----------------------------- | ----------------------------- |
| **Photo Analysis** | Analyze images from camera | Instant product cataloging |
| **Voice Commands** | Speak to agents naturally | Hands-free agent interaction |
| **Push Notifications** | Receive agent alerts anywhere | Real-time business monitoring |
### **Mobile Agent Use Cases**
**Field Service Agent:**
* Take photos of equipment issues
* Get instant diagnostic suggestions
* Create work orders automatically
* Access repair manuals contextually
**Sales Agent:**
* Capture client meeting notes via voice
* Get real-time product recommendations
* Access pricing and availability instantly
* Generate follow-up tasks automatically
## **AI Team Generator: Multi-Agent Teams**
Create entire teams of specialized AI agents with a single prompt using the revolutionary AI Team Generator.
### **What is AI Team Generator?**
The AI Team Generator lets you create complete multi-agent teams instantly. Just describe your use case, and Taskade automatically generates a fully configured AI Team with tailored roles, behaviors, and specialized toolkits.
### **When to Use AI Team Generator**
| **Scenario** | **Why It's Perfect** |
| -------------------------- | ---------------------------------------------------- |
| **Complex Workflows** | Multiple agents tackle different parts of a workflow |
| **Uncertain Structure** | AI designs the optimal team composition for you |
| **Time Constraints** | Save hours of manual agent configuration |
| **Best Practice Learning** | See how experts structure multi-agent systems |
### **Example AI Team Generations**
**Prompt:** *"Create a product launch team for a SaaS startup"*
**Generated Team:**
* **π― Product Manager Agent** - Roadmap planning, feature prioritization
* **π Market Research Agent** - Competitor analysis, user research
* **βοΈ Content Marketing Agent** - Blog posts, social media, email campaigns
* **π Growth Marketing Agent** - SEO optimization, conversion tracking
* **π¨ Design Agent** - Visual assets, UI/UX feedback
* **π¬ Customer Success Agent** - Onboarding flows, support documentation
**Prompt:** *"Build a legal compliance team for healthcare"*
**Generated Team:**
* **βοΈ Compliance Officer Agent** - HIPAA regulations, audit preparation
* **π Documentation Agent** - Policy creation, procedure updates
* **π Risk Assessment Agent** - Vulnerability analysis, mitigation strategies
* **π Reporting Agent** - Compliance reports, regulatory filings
* **π Training Agent** - Staff education, certification tracking
### **How It Works**
1. **Describe Your Need** - "I need a team for \[specific use case]"
2. **AI Analyzes Requirements** - Identifies roles, skills, and workflows needed
3. **Generates Specialized Agents** - Each with custom instructions and tools
4. **Ready to Deploy** - Start using your team immediately
### **How to Use AI Team Generator**
{% hint style="success" %}
**Step-by-Step Guide to Creating AI Teams**
{% endhint %}
#### **Access the Generator**
1. Navigate to the **Agents** tab in your workspace
2. Look for the **AI Team Generator** option
3. Click to open the team creation interface
#### **Craft Your Prompt**
{% hint style="info" %}
The quality of your prompt determines the quality of your generated team. Be specific about your use case, industry, and requirements.
{% endhint %}
**Effective Prompt Examples:**
* `"Create a customer success team for a SaaS company handling onboarding, support tickets, and retention"`
* `"Build a content marketing team for a B2B tech blog including research, writing, and promotion"`
* `"Generate a project management team for software development with sprint planning and QA"`
### **Editing and Customizing Generated Teams**
{% hint style="warning" %}
All generated teams can be fine-tuned after creation to better fit your specific needs.
{% endhint %}
#### **Available Customizations**
| **Customization Type** | **What You Can Modify** | **Impact** |
| ------------------------ | ------------------------------------------------ | ---------------------------------------- |
| **Agent Roles** | Change titles, responsibilities, and specialties | Better alignment with your workflow |
| **Instructions** | Adjust behavior, tone, and response guidelines | More accurate and helpful responses |
| **Tools & Integrations** | Add/remove connected services and APIs | Enhanced capabilities and automation |
| **Knowledge Base** | Upload additional training materials | More informed and knowledgeable agents |
| **Communication Style** | Modify how agents interact and collaborate | Better team dynamics and user experience |
#### **Advanced Editing Features**
{% stepper %}
{% step %}
#### Access Team Settings
Click the **settings icon** on your generated team
{% endstep %}
{% step %}
#### Modify Agent Configuration
Select individual agents to adjust their parameters
{% endstep %}
{% step %}
#### Test Changes
Use the **preview chat** to test modified behavior
{% endstep %}
{% step %}
#### Save and Deploy
Apply changes and make the team available for use
{% endstep %}
{% endstepper %}
### **Using Your AI Team**
{% hint style="success" %}
**Multiple Ways to Collaborate with AI Teams**
{% endhint %}
#### **Method 1: Direct Team Chat**
* Access through the **Agents** tab
* Chat with the entire team as a unified group
* All agents contribute to comprehensive responses
* Perfect for brainstorming and complex problem-solving
#### **Method 2: Project Integration**
* Assign teams to specific projects
* Agents work within project context
* Automatic task generation and updates
* Seamless integration with existing workflows
#### **Method 3: Task Assignment**
* Assign specific tasks to team members
* Each agent handles their area of expertise
* Parallel processing for faster completion
* Comprehensive reporting on progress
#### **Method 4: Automation Integration**
* Connect teams to automation workflows
* Trigger team actions based on events
* Automated responses and follow-ups
* Continuous background processing
### **AI Team Use Cases and Examples**
| **Industry** | **Team Type** | **Key Agents** | **Benefits** |
| --------------- | ------------------ | ------------------------------------- | ------------------------------ |
| **Marketing** | Content Creation | Research, Writing, Design, SEO | Complete content pipeline |
| **Sales** | Lead Management | Qualification, Follow-up, Analytics | Streamlined sales process |
| **Support** | Customer Service | Triage, Resolution, Feedback | 24/7 customer support |
| **Development** | Project Management | Planning, Coding, Testing, Deployment | Accelerated development cycles |
| **HR** | Recruitment | Sourcing, Screening, Interviewing | Efficient hiring process |
### **Best Practices for AI Teams**
{% hint style="info" %}
**Optimization Strategies for Maximum Impact**
{% endhint %}
#### **Team Composition**
* **Start Small**: Begin with 3-5 agents for focused teams
* **Role Clarity**: Ensure each agent has distinct, non-overlapping responsibilities
* **Skill Balance**: Include a mix of specialized and general-purpose agents
#### **Performance Tuning**
* **Prompt Refinement**: Iterate on team prompts for better results
* **Tool Integration**: Connect relevant external services and APIs
* **Knowledge Updates**: Regularly refresh agent knowledge bases
#### **Workflow Integration**
* **Clear Triggers**: Define when and how teams should be activated
* **Output Standards**: Establish consistent formatting and quality expectations
* **Feedback Loops**: Implement review processes for continuous improvement
### **Troubleshooting AI Teams**
| **Issue** | **Common Causes** | **Solutions** |
| --------------------------- | ------------------------- | ---------------------------------------------- |
| **Uncoordinated Responses** | Overlapping agent roles | Clarify responsibilities in team configuration |
| **Slow Response Times** | Too many agents active | Reduce team size or optimize prompts |
| **Inconsistent Quality** | Unclear instructions | Refine agent prompts and guidelines |
| **Integration Problems** | API/authentication issues | Verify tool connections and permissions |
***
**π‘ Pro Tip:** Your best agent team is one that solves a real problem you face daily. Start with a specific use case, measure results, and expand as you discover new possibilities!
# TSK-1 Model Tiers
TSK-1 (Taskade System Kernel) is the intelligence layer that auto-routes AI work across four capability tiers β vendor-agnostic, always current.
TSK-1 is not a single model. It is an **orchestration layer** β the intelligence system that coordinates how AI models, memory, agents, and workflows operate inside your workspace. When you pick a tier, TSK-1 routes your request to the best available model for that capability level.
{% hint style="success" %}
**The short version.** Set your agent to **Auto** and TSK-1 picks the right tier per request. The four tiers β Instant, Standard, Thinking, Reasoning β describe what the system is good at, not which provider powers it.
{% endhint %}
***
## How TSK-1 fits in the stack
```
Taskade β Genesis β EVE β TSK-1 β Workspace DNA β Running workspace
```
TSK-1 sits between the **EVE** persona and **Workspace DNA** β it is the engine that decides *how* to execute a given request across the Memory (projects), Intelligence (agents), Execution (automations), and Apps (Genesis) pillars.
***
## The four tiers
The model picker shows one TSK-1 header with a capability ladder. Each tier is defined by what it's good for, not by its underlying provider:
| Tier | Best for | Example use | Plans |
| ------------- | -------------------------------------------------------- | --------------------------------------------------------------------------- | ---------------- |
| **Instant** | Fast edits, simple completions, quick lookups | Rename a task, fix a typo, categorize an item | All plans |
| **Standard** | Everyday work β balanced speed and reasoning | Draft an email, summarize a document, answer a question | Paid plans |
| **Thinking** | Planning, creation, multi-step reasoning | Design an automation flow, write a project proposal, generate a Genesis app | Business and up |
| **Reasoning** | Complex systems, deep analysis, multi-agent coordination | Audit a workspace, cross-reference databases, run a multi-agent team | Max & Enterprise |
Every tier is visible in the picker on every plan; manually pinning a tier requires the plan shown. **Auto** is available on every plan and can route a request to any tier based on the task β which is how Free-plan builds reach Reasoning depth (see below).
***
## Auto (recommended)
Set your agent to **Auto** and TSK-1 dynamically routes each request to the appropriate tier β fast when you need speed, deep when you need reasoning. Auto is the default for new agents on every plan.
**Free plan included.** On the Free plan, Auto runs your first Genesis app build at full **Reasoning** depth and follow-up edits at **Thinking** depth β welcome credits (1,000 when you verify your account, plus 5,000 when you start your first app build) are sized to cover one complete build.
Agents or automations **pinned to a specific tier** stay on that tier until you change them. The tier definitions are stable; the underlying models that serve each tier may change as the frontier improves.
{% hint style="info" %}
**Model lineup may change.** TSK-1 runs on the latest frontier models. Because the tiers describe capability rather than provider, Taskade can upgrade the underlying models without you needing to reconfigure anything. The in-app model picker always reflects the current tier lineup.
{% endhint %}
***
## When to pin a tier vs. use Auto
| Scenario | Recommendation |
| ---------------------------------------------------------------- | ---------------------------------------------------- |
| General-purpose agent β chat, answer questions, draft content | **Auto** β let TSK-1 decide |
| High-volume automation that needs low latency and low cost | **Instant** or **Standard** |
| Agent that designs workflows, apps, or complex plans | **Thinking** |
| Agent that audits, cross-references, or coordinates other agents | **Reasoning** |
| You have a specific model preference from prior testing | Custom model (available on Max and Enterprise plans) |
Agents pinned to a **custom model** (e.g. a specific Claude or GPT version) bypass TSK-1 routing entirely β they always use that model. This is available on Max and Enterprise plans.
***
## Credits
Each tier has its own credit rate, shown in the in-app model picker. Auto routes to the tier it selects, billing at that tier's rate. Pinned custom models bill at the model's own rate.
See [Credits & Billing](/help/account-management/credits-and-billing) for current rates.
***
## Workspace DNA
TSK-1 powers all four pillars of Workspace DNA:
1. **Projects remember** β your data and context stay connected.
2. **Agents reason** β multi-agent teams understand goals and take action.
3. **Workflows run** β automations continue after chat ends.
4. **Apps launch** β one prompt, one live app.
For the full architecture, see [How Taskade Genesis Works](/taskade-genesis/genesis/how-genesis-works).
***
## What's next
| Guide | What you'll learn |
| ------------------------------------------------------------------------------- | ----------------------------------------------- |
| [AI Agents Getting Started](/ai-features/ai-features/ai-agents-getting-started) | Set up your first agent and choose a TSK-1 tier |
| [Agent Knowledge & Memory](/ai-features/ai-features/agent-knowledge) | Give agents context from your projects |
| [Multi-Agent Collaboration](/ai-features/ai-features/multi-agents) | Coordinate multiple agents with TSK-1 Reasoning |
| [Credits & Billing](/help/account-management/credits-and-billing) | Understand credit costs per tier |
# Agent Knowledge & Memory
Train Taskade AI agents on your own knowledge: upload PDFs, CSVs, and docs, add URLs and YouTube, or connect projects as live, auto-updating sources.
***
## Table of Contents
* [Overview](#overview)
* [Explore the Knowledge Tab](#explore-the-knowledge-tab)
* [Train Your Agent](#train-your-agent)
* [Supported Knowledge Sources](#supported-knowledge-sources)
* [Training Methods](#training-methods)
* [Upload Documents](#upload-documents)
* [Use Web Resources](#use-web-resources)
* [Create Sources Manually](#create-sources-manually)
* [Dynamic Knowledge (Projects)](#dynamic-knowledge-projects)
* [Bulk Training](#bulk-training)
* [Look Up References](#look-up-references)
* [Knowledge Backlinks](#knowledge-backlinks)
* [What Projects Expose to Agents](#what-projects-expose-to-agents)
* [Knowledge Best Practices](#knowledge-best-practices)
* [What's Next](#whats-next)
***
## Overview
Agent knowledge is the information your custom AI agents use to provide **contextual, accurate responses**. It combines pre-trained AI capabilities with **your own data** β documents, URLs, projects, and media β to create agents that truly understand your business.
> **Workspace DNA connection:** Knowledge is what transforms a generic AI into a specialist. The more knowledge you add, the richer your [Workspace DNA](/taskade-genesis/genesis/how-genesis-works) becomes, and the smarter all your Taskade Genesis apps get.
***
## Explore the Knowledge Tab
| Step | Action |
| ---- | ------------------------------------------- |
| 1 | Go to the **Agents** tab |
| 2 | Click the three dots (β―) next to your agent |
| 3 | Select **Edit agent** |
| 4 | Open the **Knowledge** tab |
The Knowledge tab shows all sources your agent has been trained on, with options to add, remove, and manage sources.
***
## Train Your Agent
### Supported Knowledge Sources
| Source Type | Formats / Types | How It's Used |
| -------------------- | --------------------------------------------------- | ----------------------------------------------- |
| **Documents** | PDF, CSV, TXT, DOCX, MD, PPTX, XLSX, EPUB | Full text extraction and indexing |
| **Web URLs** | Any web page, blog post, documentation page | Content scraped and indexed |
| **YouTube videos** | Video URLs | Transcript extracted and indexed |
| **Social content** | Tweets, Reddit posts, news articles | Content extracted and indexed |
| **Cloud files** | Google Drive, Dropbox, Box, OneDrive | File content pulled and indexed |
| **Taskade projects** | Any project in your workspace | Live, dynamic knowledge (updates automatically) |
| **Manual sources** | Markdown or plain text created in the Knowledge tab | Direct knowledge injection |
***
## Training Methods
### Upload Documents
| Step | Action |
| ---- | -------------------------------------------------- |
| 1 | Open the Knowledge tab |
| 2 | Drag & drop files directly, or click **Add Media** |
| 3 | Select files from your device |
| 4 | Files are processed and indexed automatically |
**Supported document formats:**
| Format | Best For |
| -------------- | ----------------------------------------------- |
| **PDF** | Brand guidelines, reports, manuals, legal docs |
| **CSV / XLSX** | Customer data, product catalogs, pricing tables |
| **DOCX** | Procedures, policies, templates |
| **TXT / MD** | Plain text knowledge, FAQ answers, notes |
| **PPTX** | Presentations, training materials |
| **EPUB** | Books, long-form content |
### Use Web Resources
| Step | Action |
| ---- | ------------------------------------------------------ |
| 1 | Click **Add Media** in the Knowledge tab |
| 2 | Paste a URL (web page, YouTube video, cloud file link) |
| 3 | Content is scraped/transcribed and indexed |
| Resource Type | What Gets Indexed |
| ---------------------------------- | ------------------------- |
| **Web pages** | Full page text content |
| **YouTube videos** | Full video transcript |
| **Google Drive files** | Document text content |
| **Dropbox / Box / OneDrive files** | Document text content |
| **Blog posts** | Article text and metadata |
| **Tweets** | Tweet text and thread |
| **Reddit posts** | Post and top comments |
| **News articles** | Full article text |
### Create Sources Manually
| Step | Action |
| ---- | -------------------------------------------------------- |
| 1 | Open the Knowledge tab |
| 2 | Click **"Create Source"** |
| 3 | Write or paste Markdown/plain text directly |
| 4 | Save β the source is immediately available to your agent |
> **Tip:** Use manual sources for FAQ answers, custom instructions, edge case handling, or information not available in any file.
### Dynamic Knowledge (Projects)
Connect Taskade projects as **living knowledge sources** that update automatically:
| Step | Action |
| ---- | ----------------------------------------------------------------- |
| 1 | Open the Knowledge tab |
| 2 | Click **Add Media** β **Add from Workspace** |
| 3 | Select one or more projects |
| 4 | Projects become live knowledge β agent always has the latest data |
> **Dynamic = real-time.** When you update a project, the agent's knowledge updates automatically. No re-upload needed.
***
## Bulk Training
Upload multiple sources simultaneously:
| Method | How |
| ------------------------- | ------------------------------------------------------ |
| **Multi-file upload** | Select multiple files in the file picker |
| **Multi-project connect** | Select multiple projects from your workspace |
| **Multi-URL paste** | Add multiple links at once |
| **Drag & drop batch** | Drag a folder or multiple files into the Knowledge tab |
***
## Look Up References
When your agent responds, it shows which sources it referenced:
| Feature | Detail |
| ---------------------- | -------------------------------------------------------- |
| **Source citations** | Chat displays which knowledge sources were used |
| **Preview capability** | Click a citation to preview the source content |
| **Transparency** | Users can verify agent responses against source material |
***
## Knowledge Backlinks
Projects used as agent knowledge show **backlinks** indicating which agents reference them:
| Feature | Detail |
| ---------------------------- | ---------------------------------------------------------------- |
| **Backlink indicator** | Projects display a badge showing connected agents |
| **Bi-directional awareness** | See which agents use a project, and which projects an agent uses |
| **Impact visibility** | Know which agents are affected when you edit a project |
> **Tip:** Backlinks help you maintain knowledge integrity. Before editing a project, check its backlinks to understand which agents depend on it.
***
## What Projects Expose to Agents
When a project is connected as knowledge, agents can access:
| Accessible | Not Accessible |
| --------------------------------------------- | -------------------------------------------- |
| Text content (tasks, notes, descriptions) | Uploaded file attachments within the project |
| Block structure (headings, lists, checklists) | Comments on tasks |
| Due dates | Embedded links within task descriptions |
| Assignee information | Reactions (emojis) |
| Timer data | Chat messages in the project |
| Custom field values | |
| Labels and tags | |
***
## Knowledge Best Practices
| Practice | Why | Example |
| ---------------------------------- | --------------------------------------------- | ----------------------------------------------------- |
| **Start with your most-used docs** | Highest ROI knowledge sources | FAQ doc, product guide, pricing sheet |
| **Use projects for dynamic data** | Always up-to-date, no re-uploading | Customer list project, inventory project |
| **Create manual sources for gaps** | Fill knowledge holes quickly | Edge case handling, tone guidelines |
| **Organize by topic** | Helps agent find relevant info faster | Separate "Product" and "Pricing" sources |
| **Update regularly** | Stale knowledge = wrong answers | Quarterly review of all knowledge sources |
| **Test with real questions** | Verify agent uses knowledge correctly | Ask questions you know the answers to |
| **Use backlinks to audit** | Understand cross-dependencies | Check before editing shared projects |
| **Upload diverse formats** | Different formats capture different knowledge | PDFs for detail, CSVs for data, URLs for current info |
***
## What's Next
| Guide | What You'll Learn |
| ---------------------------------------------------------------------- | -------------------------------------------- |
| [Tools for AI Agents](/ai-features/ai-features/agent-tools) | Add action capabilities to your agents |
| [Custom AI Agents](/ai-features/ai-features/ai-agents-getting-started) | Build and configure agents from scratch |
| [Multi-Agents](/ai-features/ai-features/multi-agents) | Create teams of agents with shared knowledge |
| [Projects & Databases](/workspaces/workspaces/projects-databases) | Structure data for optimal agent training |
| [Adding Genesis Context](/taskade-genesis/genesis/adding-context) | Upload context for Genesis app creation |
# Tools for AI Agents
Give Taskade AI agents real actions: add native tools, Slack/Gmail/HubSpot integrations, custom automation tools, and human-in-the-loop approvals.
***
## Table of Contents
* [Overview](#overview)
* [Add Tools to Agents](#add-tools-to-agents)
* [Use Agent Tools](#use-agent-tools)
* [Taskade Native Tools](#taskade-native-tools)
* [Agent Actions (Full Reference)](#agent-actions-full-reference)
* [Taskade AI (Cross-Agent)](#taskade-ai-cross-agent)
* [Media Tools](#media-tools)
* [App Tools (Third-Party Integrations)](#app-tools-third-party-integrations)
* [Build Custom Agent Tools](#build-custom-agent-tools)
* [Human in the Loop](#human-in-the-loop)
* [Enable / Disable Tools](#enable-disable-tools)
* [What's Next](#whats-next)
***
## Overview
Agent Tools are integrated add-ons that **augment your AI agents' capabilities** β allowing them to interact with Taskade projects, third-party platforms, and custom workflows. Tools transform agents from text-only assistants into autonomous actors that can take real actions on your behalf.
> **Workspace DNA connection:** Tools are how agents execute the [Automation pillar](/automations/automation). An agent with tools can send Slack messages, create HubSpot deals, update Google Sheets, and more β all within the conversation.
***
## Add Tools to Agents
| Step | Action |
| ---- | ------------------------------------------------------------ |
| 1 | Go to the **Agents** tab |
| 2 | Click the three dots (β―) next to your agent β **Edit agent** |
| 3 | Open the **Tools** tab |
| 4 | Click **Add tools** |
| 5 | Select from Taskade tools and/or third-party integrations |
| 6 | Save |
***
## Use Agent Tools
Agents can use tools through three interfaces:
| Method | How | Best For |
| ----------------- | ------------------------------------------------------------------------ | --------------------------- |
| **Project Chat** | Chat with an agent in a project context β agent uses tools automatically | Project-specific actions |
| **Agent Sidebar** | Access agent in the sidebar β tools available in conversation | Quick actions while working |
| **Agent Chat** | Dedicated agent chat session β full tool access | Complex multi-step tasks |
> **Agents decide when to use tools.** You don't need to explicitly request a tool β describe what you want, and the agent determines which tool to use.
***
## Taskade Native Tools
### Agent Actions (Full Reference)
These are built-in Taskade actions every agent can perform in your workspace:
| Category | Actions | Example Prompts |
| -------------------------- | ----------------------------------------- | ------------------------------------------------------------------------------ |
| **Bulk AI Prompts** | Run AI commands across multiple items | "Summarize all tasks in this project", "Translate all items to Spanish" |
| **Project & Task Editing** | Create, update, delete projects and tasks | "Create a new task called 'Review proposal'", "Rename this project to Q2 Plan" |
| **Content Updates** | Modify task descriptions, notes, content | "Add detailed instructions to the 'Setup server' task" |
| **Task Completion** | Mark tasks complete or reopen them | "Mark all tasks under 'Phase 1' as complete" |
| **Due Date Management** | Set, update, remove due dates | "Set the deadline for 'Launch campaign' to next Friday" |
| **Assignments** | Assign or unassign team members | "Assign @Sarah to all tasks in the Marketing section" |
| **Labels & Tags** | Add, remove, manage labels | "Add the 'urgent' label to all overdue tasks" |
| **Task Movement** | Reorder, move tasks between sections | "Move all completed tasks to the 'Done' section" |
| **Smart Editing** | Restructure, reorganize, reformat content | "Convert this brainstorm list into an organized project plan" |
| **Notes & Comments** | Add notes, comments, annotations | "Add a note to this task explaining the delay" |
| **Insights & Reporting** | Analyze project data, generate reports | "Give me a status summary of all projects due this week" |
| **Governance & Safety** | Permission checks, access validation | "Who has access to this project?" |
| **Custom Fields** | Create, update, manage custom fields | "Add a 'Priority' custom field with options: High, Medium, Low" |
| **Search & Intelligence** | Search across workspace, find patterns | "Find all tasks assigned to @John that are overdue" |
| **Content Generation** | Generate text, documents, summaries | "Write a project brief for the new product launch" |
| **Compare & Review** | Diff content, review changes | "Compare this week's metrics to last week's" |
### Taskade AI (Cross-Agent)
| Capability | What It Does | Example |
| ---------------------- | ---------------------------------------------- | --------------------------------------------------- |
| **Ask other agents** | Query another agent from within a conversation | "Ask the Sales Agent about our latest lead metrics" |
| **Run agent commands** | Execute another agent's custom commands | "Run the Report Agent's `/weekly-summary` command" |
### Media Tools
| Tool | What It Does | Example |
| ---------------------- | ------------------------------------------- | ------------------------------------------------------------ |
| **Search Web** | Search the internet for current information | "Search for the latest pricing trends in SaaS" |
| **Scrape Webpage** | Extract content from any web page | "Scrape the competitor's pricing page and summarize" |
| **Transcribe YouTube** | Get full transcript from any YouTube video | "Transcribe this product demo video and create action items" |
***
## App Tools (Third-Party Integrations)
Connect your agents to external platforms for real-world actions:
| Category | Platform | Capabilities | Example Use |
| ----------------- | --------------------- | ------------------------------------------------------------ | ---------------------------------- |
| **Communication** | **Slack** | Send channel messages, send DMs, create channels, find users | Agent posts daily standup to #team |
| | **Discord** | Send messages to channels and users | Agent posts community updates |
| | **Microsoft Teams** | Create channels, send channel/chat messages | Agent notifies team of events |
| | **WhatsApp Business** | Send messages to contacts | Agent handles customer comms |
| | **Telegram** | Send messages, manage groups | Agent broadcasts announcements |
| | **Twilio** | Send SMS messages | Agent sends appointment reminders |
| | **Zoom** | Schedule meetings | Agent books video calls |
| **Email** | **Gmail** | Send emails, find emails, create drafts | Agent sends follow-up emails |
| | **Outlook** | Send emails, manage calendar | Agent handles enterprise email |
| **CRM & Sales** | **HubSpot** | Create contacts, create deals, update records | Agent creates CRM records |
| | **Salesforce** | Manage contacts, opportunities, cases | Agent updates enterprise CRM |
| | **Apollo** | Enrich contacts, find leads | Agent enriches lead data |
| **Productivity** | **Google Sheets** | Insert rows, find rows, update cells | Agent logs data to sheets |
| | **Google Docs** | Create documents, append text, find documents | Agent generates documents |
| | **Google Calendar** | Create events, create quick events | Agent schedules meetings |
| | **Google Drive** | Create folders/files, search, duplicate, manage permissions | Agent organizes files |
| | **Google Forms** | Process form responses | Agent handles form data |
| | **Calendly** | Manage scheduling | Agent books appointments |
| | **Typeform** | Process form submissions | Agent handles surveys |
| **Social Media** | **Twitter/X** | Create posts, manage content | Agent posts social updates |
| | **LinkedIn** | Create company updates, publish articles | Agent publishes company news |
| | **Facebook** | Create page posts, manage content | Agent manages page posts |
| | **Instagram** | Create posts, manage content | Agent publishes visual content |
| | **Reddit** | Create posts, monitor threads | Agent engages communities |
| | **TikTok** | Manage content | Agent publishes video content |
| | **YouTube** | Transcribe videos, manage content | Agent processes video content |
| **Content** | **WordPress** | Create blog posts, manage content | Agent publishes content |
| | **Webflow** | Manage CMS content | Agent updates web content |
| | **RSS** | Monitor feeds | Agent tracks content sources |
| **Development** | **GitHub** | Manage issues, PRs, repositories | Agent tracks development |
| | **HTTP/Webhooks** | Custom API requests with analyzer | Agent connects to any API |
| | **Bitbucket** | Manage issues, repositories | Agent tracks code changes |
| **Business** | **Stripe** | Process payments, manage subscriptions | Agent handles billing |
| | **Mailchimp** | Add contacts, manage campaigns | Agent manages email marketing |
> **104 automation actions** and **40+ external service integrations** are available. Agents can use any automation flow as a custom tool. See [Automations](/automations/automation) for the full integration list.
> **For developers:** The **HTTP/Webhooks** custom tool lets agents call any external API. See [Webhooks](/developers/webhooks) for programmatic event delivery and payload details.
***
## Build Custom Agent Tools
Turn any automation flow into a reusable agent tool:
| Step | Action |
| ---- | ---------------------------------------------- |
| 1 | Open your agent's **Tools** tab |
| 2 | Click **New tool** |
| 3 | Design the automation flow (trigger β actions) |
| 4 | Save as a custom tool |
| 5 | The agent can now execute this flow on command |
**Example custom tools:**
| Custom Tool | Automation Flow | Trigger |
| ------------------------ | ---------------------------------------------------------------------- | ----------------------------------------- |
| "Generate weekly report" | Gather project data β Summarize β Email to team β Post to Slack | Agent decides or `/weekly-report` command |
| "Onboard new client" | Create project β Add template tasks β Send welcome email β Notify team | Agent processes new client request |
| "Escalate issue" | Create urgent ticket β Notify manager via Slack β Schedule follow-up | Agent detects high-severity issue |
> **Deep dive:** [Automations: The Execution Pillar](/automations/automation) for full automation flow building.
***
## Human in the Loop
For sensitive external actions, enable approval before execution:
| Feature | Detail |
| ---------------- | ------------------------------------------------------------------------------------ |
| **What it is** | An approve/reject gate before agents interact with external platforms |
| **When to use** | Sending emails, posting to social media, creating CRM records, any external action |
| **How it works** | Agent proposes the action β You review β Approve or Reject β Agent proceeds or stops |
| Step | Action |
| ---- | ------------------------------------------------------------------------------ |
| 1 | Enable "Human in the Loop" in the Tools tab |
| 2 | Select which tools require approval |
| 3 | When the agent wants to use an approved tool, you'll see a confirmation prompt |
| 4 | Click **Approve** to proceed or **Reject** to stop |
> **Tip:** Use Human in the Loop during the first few weeks of agent deployment. Once you trust the agent's judgment, disable it for routine actions.
***
## Enable / Disable Tools
| Action | How |
| -------------- | ---------------------------------------- |
| Enable a tool | Toggle ON in the Tools tab |
| Disable a tool | Toggle OFF in the Tools tab |
| Remove a tool | Click the remove button next to the tool |
> **Disabled tools** remain configured but are not available to the agent. Re-enable anytime without reconfiguration.
***
## What's Next
| Guide | What You'll Learn |
| ---------------------------------------------------------------------- | ---------------------------------------------- |
| [Multi-Agents](/ai-features/ai-features/multi-agents) | Build teams of agents with complementary tools |
| [Agent Knowledge & Memory](/ai-features/ai-features/agent-knowledge) | Train agents on your data |
| [Automations](/automations/automation) | Build the automation flows agents can trigger |
| [Custom AI Agents](/ai-features/ai-features/ai-agents-getting-started) | Complete agent setup guide |
# AI Agent Teams
Create teams of AI agents that work together β Taskade automatically picks the best-qualified agent to respond, or lets them collaborate on complex tasks.
A single agent is powerful. A **team** of agents is transformative. AI Agent Teams let you group multiple specialized agents so they can work together β Taskade automatically routes each request to the agent best equipped to handle it.
{% hint style="info" %}
**Think of it like a real team.** You don't ask your accountant to write marketing copy. Agent Teams apply the same principle: the right specialist handles the right task, every time.
{% endhint %}
## Create a Team
1. Open the **AI Teams** tab in your workspace.
2. Click **Create Team**.
3. Give your team a name and description.
4. Select the agents you want to include (minimum 2).
5. Click **Create**.
Your team is ready to use immediately.
### Create a Team with AI
Don't know which agents to include? Let AI figure it out.
1. In the **AI Teams** tab, click **Create with AI**.
2. Describe what you need the team to do (e.g., "A content marketing team that handles blog writing, SEO optimization, and social media scheduling").
3. Press **Enter**.
4. Taskade generates a fully configured team with specialized agents, roles, and tools.
5. Review, adjust if needed, and save.
{% hint style="success" %}
**The AI Team Generator is the fastest way to get started.** Describe a business function and get a working team in seconds. You can always fine-tune individual agents later.
{% endhint %}
## How to Use Your Team
### Chat in the AI Teams Tab
Go to **AI Teams** > select your team > start a conversation. The team collectively handles your request, with each agent contributing their expertise.
### Chat Inside a Project
1. Open any project.
2. Click the **chat balloon** icon.
3. Switch to the **AI Teams** tab in the chat panel.
4. Select your team and start chatting.
The team responds using the project as context, so answers are grounded in your actual work.
### Assign a Team to Tasks
In any project, type **/** followed by the team name to assign the team to a task. The team picks the right agent to handle the work based on the task content.
## Execution Modes
Execution modes control **how** your team responds. Choose the mode that fits your workflow.
| Mode | What Happens | Best For |
| --------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
| **Auto** | Taskade picks the best agent(s) based on your prompt | Most everyday requests β fast and hands-off |
| **Everyone** | All agents respond independently, each with their own answer | Getting diverse perspectives or second opinions |
| **Orchestrate** | All agents collaborate together on a single unified response | Complex tasks that need multiple areas of expertise combined |
{% hint style="info" %}
**Start with Auto mode.** It works well for most situations. Switch to other modes when you need more control or want to see how different agents approach the same problem.
{% endhint %}
### When to use each mode
**Auto** β "Handle this customer inquiry" (let the system route it)
**Everyone** β "What should our Q2 strategy be?" (get input from every perspective)
**Orchestrate** β "Write a product launch plan covering marketing, pricing, and support" (multiple specialists, one cohesive output)
## Use Cases
### Customer Support Team
Combine agents specialized in billing, technical issues, and account management. Incoming questions automatically go to the right specialist.
### Research Panel
Group a market research agent, a competitive analysis agent, and a data analyst agent. Ask a strategic question and get a comprehensive answer from multiple angles.
### Content Creation Pipeline
Team up a research agent, a writing agent, an SEO agent, and a social media agent. One prompt can produce a blog post, optimize it for search, and draft social posts to promote it.
### Sales Qualification
Combine a lead research agent, a qualification agent, and an outreach agent. Feed in a list of prospects and get qualified leads with personalized follow-up drafts.
## Tips for Effective Teams
* **Give each agent a clear specialty.** Overlapping roles cause confusion about who should respond. If two agents cover "marketing," narrow one to "content" and the other to "paid ads."
* **Keep teams focused.** 3 to 5 agents per team is the sweet spot. Larger teams slow down routing and produce noisier results.
* **Train agents individually first.** Make sure each agent performs well on its own before adding it to a team. A team is only as strong as its weakest member.
* **Use descriptive team names.** "Customer Success Team" is better than "Team 1." Clear names help you (and your teammates) pick the right team quickly.
## Next Steps
* [AI Agent Tools](/ai-features/ai-features/agent-tools) β give each agent the ability to take action
* [Agent Knowledge & Memory](/ai-features/ai-features/agent-knowledge) β train agents with your business data
* [AI Agents Getting Started](/ai-features/ai-features/ai-agents-getting-started) β create individual agents before building teams
* [Automation Recipes](/automations/automation/recipes) β connect teams to automated workflows
# Multi-Agent Collaboration
Build teams of specialized AI agents in Taskade that collaborate on projects, with Taskade EVE orchestrating handoffs, multi-agent patterns, and shared chat.
***
## Table of Contents
* [Overview](#overview)
* [Set Up Your AI Agents](#set-up-your-ai-agents)
* [Team Up with AI Agents](#team-up-with-ai-agents)
* [Use the Agent Sidebar](#use-the-agent-sidebar)
* [Iterate on Output](#iterate-on-output)
* [Chat with Agents & Your Team](#chat-with-agents-and-your-team)
* [Copy / Duplicate Multi-Agents](#copy-duplicate-multi-agents)
* [Share Agents](#share-agents)
* [Multi-Agent Architecture Patterns](#multi-agent-architecture-patterns)
* [What's Next](#whats-next)
***
## Overview
Multi-Agents lets you **assign multiple AI agents to work together** on projects, tasks, and conversations. Instead of relying on a single generalist AI, you create teams of specialized agents that collaborate β each bringing domain expertise, unique knowledge, and specific tools.
Specialized agents, Taskade EVE, and people coordinate around one shared project.
```mermaid
graph TD
HUMAN["Human team members
direction and decisions"] --> WS["Shared project / workspace"]
WS --> EVE["Taskade EVE
orchestrates and invokes agents"]
EVE --> RES["Research Agent"]
EVE --> ANL["Analyst Agent"]
EVE --> WRT["Writer Agent"]
EVE --> COORD["Coordinator Agent"]
RES --> WS
ANL --> WS
WRT --> WS
COORD --> WS
```
> **Workspace DNA impact:** Multi-agent teams amplify the Intelligence pillar. Each agent contributes +10 points to your [Intelligence Score](/taskade-genesis/genesis/how-genesis-works#workspace-intelligence-score), and teams create compounding intelligence through specialization.
>
> **Plan note:** Multi-Agent Teams are available on Business+ plans.
***
## Set Up Your AI Agents
### Method 1: Build from Scratch
| Step | Action |
| ---- | ------------------------------------------------ |
| 1 | Open the **Agents** tab in your workspace |
| 2 | Click **Create Agent** |
| 3 | Configure: name, persona, tone, knowledge, tools |
| 4 | Repeat for each specialized agent in your team |
### Method 2: Use Templates
| Step | Action |
| ---- | ----------------------------------------------- |
| 1 | Browse the agent template library |
| 2 | Select pre-built agent templates for each role |
| 3 | Customize each agent for your specific use case |
### Method 3: Auto-Generate a Team with AI
The fastest way to create a multi-agent team:
| Step | Action |
| ---- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1 | Open the **Agents** tab |
| 2 | Click **Create Agent Team** |
| 3 | Describe your team in plain English (e.g., "I need a marketing team with a content writer, SEO specialist, social media manager, and analytics analyst") |
| 4 | AI generates the complete team with specialized agents, knowledge sources, and tool configurations |
| 5 | Review and customize each agent as needed |
> **Pro tip:** Auto-generated teams include appropriate personas, knowledge connections, and tool assignments based on your description. You can always fine-tune each agent individually afterward.
**Example team setup:**
| Agent | Specialty | Knowledge | Tools |
| --------------------- | ----------------------------- | --------------------------------- | --------------------------------------- |
| **Research Agent** | Data gathering, web search | Industry reports, competitor URLs | Search Web, Scrape Webpage |
| **Analyst Agent** | Data analysis, insights | Historical data projects, KPIs | Google Sheets, Custom Fields |
| **Writer Agent** | Content creation, copywriting | Brand guidelines, tone docs | Google Docs, WordPress |
| **Coordinator Agent** | Task management, routing | Team structure, processes | Slack, Google Calendar, Taskade Actions |
***
## Team Up with AI Agents
### Assign a Single Agent
| Step | Action |
| ---- | -------------------------------------------------------- |
| 1 | Open a project or task |
| 2 | Click the **Agent** icon |
| 3 | Select an agent from your workspace |
| 4 | The agent now has context for that specific project/task |
### Assign Multiple Agents
| Step | Action |
| ---- | ----------------------------------------------- |
| 1 | Open a project |
| 2 | Click the **Agent** icon |
| 3 | Select multiple agents for the project |
| 4 | Each agent applies its specialty to the project |
### Bulk-Assign Agents
| Step | Action |
| ---- | ----------------------------------------- |
| 1 | Select multiple tasks or projects |
| 2 | Use bulk actions to assign agents |
| 3 | Agents are assigned to all selected items |
***
## Use the Agent Sidebar
| Feature | Detail |
| --------------------- | ---------------------------------------------------- |
| **Access** | Click the Agent icon in the sidebar |
| **Switch agents** | Toggle between assigned agents mid-conversation |
| **Context awareness** | Agent sees the project/task you're currently viewing |
| **Tool access** | All enabled tools are available in the sidebar |
| **History** | Conversation history preserved per agent |
***
## Iterate on Output
Multi-agent output can be refined iteratively:
| Technique | Example |
| ------------------------- | -------------------------------------------------------------------- |
| **Sequential refinement** | Research Agent drafts β Writer Agent refines β Reviewer Agent checks |
| **Parallel generation** | Multiple agents tackle different sections simultaneously |
| **Feedback loop** | Ask one agent to critique another agent's output |
| **Role switching** | "Now have the Analyst Agent review what the Writer Agent produced" |
***
## Chat with Agents & Your Team
Multi-agent chats support both AI agents and human team members in the same conversation:
| Participant | Role |
| ---------------------- | ---------------------------------------------- |
| **AI Agents** | Respond based on knowledge and tools |
| **Human team members** | Provide direction, make decisions, add context |
| **EVE** | Orchestrates and can invoke other agents |
> **Tip:** @mention specific agents in chat to direct questions or tasks to them.
***
## Copy / Duplicate Multi-Agents
| Action | How | Result |
| --------------------------- | --------------------------------------------------- | ---------------------------------------------------------- |
| **Copy an agent** | Agent settings β Duplicate | Creates an identical copy you can customize |
| **Copy a team** | Duplicate the project with agent assignments | All agents and their assignments are copied |
| **Share across workspaces** | Publish agent publicly β Clone in another workspace | Agent config is replicated (knowledge may need re-linking) |
***
## Share Agents
| Sharing Method | Scope | How |
| ----------------------------------- | ---------------- | -------------------------------------------------------- |
| **Within workspace** | Team members | Agents are available to all workspace members by default |
| **Cross-workspace** | Other workspaces | Publish publicly β Clone |
| **Public** | Anyone | Publish with public toggle |
| **Embedded in Taskade Genesis app** | App users | Add agent chat widget to your Genesis app |
***
## Multi-Agent Architecture Patterns
| Pattern | Description | Best For | Example |
| ----------------------- | --------------------------------------------------- | --------------------------------- | ---------------------------------------------------------------------- |
| **Sequential Pipeline** | Agent A β Agent B β Agent C (output flows linearly) | Content creation, data processing | Research β Write β Review |
| **Hub and Spoke** | Central coordinator routes to specialists | Customer support, complex queries | Coordinator β routes to Sales/Support/Billing |
| **Parallel Fan-Out** | Multiple agents work simultaneously | Report generation, data analysis | Finance + Marketing + Operations agents each analyze their domain |
| **Debate / Review** | Agents critique each other's work | Quality control, decision-making | Proposal Agent creates β Critic Agent reviews β Proposal Agent revises |
| **Escalation Chain** | Start with generalist, escalate to specialist | Support tiers, triage | Tier 1 Agent β Tier 2 Specialist β Human escalation |
***
## What's Next
| Guide | What You'll Learn |
| ---------------------------------------------------------------------- | ------------------------------------------------ |
| [Custom AI Agents](/ai-features/ai-features/ai-agents-getting-started) | Build individual agents |
| [Agent Knowledge & Memory](/ai-features/ai-features/agent-knowledge) | Train agents with domain knowledge |
| [Tools for AI Agents](/ai-features/ai-features/agent-tools) | Add capabilities to each agent |
| [Automations](/automations/automation) | Connect agents to automated workflows |
| [Autonomous Agents (API)](/developers/autonomous-agents) | Orchestrate multi-agent systems programmatically |
# Image Generation
Generate images for Taskade Genesis apps natively in EVE chat with ready-to-use prompt templates. Auto-saved to Media in 1:1, 16:9, or 9:16.
***
## Table of Contents
* [Overview](#overview)
* [Generate Images in Chat](#generate-images-in-chat)
* [What to Use Images For](#what-to-use-images-for)
* [Prompt Templates by Category](#prompt-templates-by-category)
* [Profile Photos](#profile-photos)
* [Product & Listing Images](#product-and-listing-images)
* [Backgrounds & Textures](#backgrounds-and-textures)
* [Icons & UI Elements](#icons-and-ui-elements)
* [Marketing & Branding](#marketing-and-branding)
* [Image Generation Best Practices](#image-generation-best-practices)
* [What's Next](#whats-next)
***
## Overview
You can generate images for your Taskade Genesis apps **natively** β no extra tools needed. Images are created directly in chat and automatically saved to your Media library for reuse across your entire workspace.
| Feature | Detail |
| ---------------------------------- | ----------------------------------------------------------- |
| **Chat-native creation** | Describe what you need, generate instantly in EVE chat |
| **Auto-save to Media** | Every generated image is stored in your workspace Media tab |
| **Built for Taskade Genesis apps** | Use images in websites, tools, dashboards, and more |
| **Multiple aspect ratios** | 1:1 (square), 16:9 (landscape), 9:16 (portrait) |
| **Batch generation** | Generate sets of consistent images in a single prompt |
| **Reusable everywhere** | Use in any Genesis app, project, or agent knowledge base |
> **Powered by EVE:** Image generation is part of EVE, Taskade's unified AI. See [How Genesis Works](/taskade-genesis/genesis/how-genesis-works#eve-the-unified-intelligence) to understand how EVE connects everything.
***
## Generate Images in Chat
| Step | Action |
| ---- | --------------------------------------------------------------------- |
| 1 | Open your Genesis app in Taskade |
| 2 | Open EVE / Taskade Assistant Agent chat |
| 3 | Describe the image you want (use templates below) |
| 4 | Send the message and wait for generation |
| 5 | Use immediately in your app, or access anytime from the **Media** tab |
> **Note:** Images generated in chat automatically appear in Media and count toward your AI credit usage. See [Taskade AI Credits](https://www.taskade.com/learn/agents/ai-usage).
***
## What to Use Images For
| Use Case | Examples | Impact |
| ----------------------- | ----------------------------------------------------- | ------------------------------ |
| **App branding** | Cover images, headers, section banners, icons | Professional first impression |
| **Records & databases** | Product photos, client logos, listing visuals | Rich, visual data presentation |
| **Dashboards** | Tiles, category images, visual summaries | Easier information scanning |
| **Documentation** | How-to visuals, onboarding screens, SOP illustrations | Better user comprehension |
| **Marketing** | Social media cards, promotional banners, hero images | Engagement and conversion |
| **Placeholder content** | Demo data visuals, sample profiles, example products | Polished prototypes |
| **Agent avatars** | Custom profile images for AI agents | Personalized AI interactions |
***
## Prompt Templates by Category
Copy these prompts directly β swap in your specific details.
### Profile Photos
| Use Case | Prompt | Best For |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- |
| **Persona avatar** | "Generate a 1:1 (square) professional headshot of a friendly customer support manager. Studio lighting, centered framing, shoulders-up, natural skin tones. Solid light-gray background. No text, no logos, no transparent areas." | Agent avatars, demo profiles |
| **Avatar set** | "Generate a set of six 1:1 (square) profile photos (diverse people) for a Genesis app team directory. Keep identical framing, lighting, and style across all images. Solid background colors (light gray, soft blue, soft green). No text, no transparent background." | Team directories, user demos |
| **Member profile** | "Generate a 1:1 (square) profile photo of a professional account manager. Neutral expression, clean wardrobe, centered, studio lighting. Solid pale-blue background. No text, no logos, no transparency." | Customer/member profiles |
### Product & Listing Images
| Use Case | Prompt | Best For |
| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- |
| **Product photo** | "Generate a 1:1 (square) studio product photo of a reusable stainless-steel water bottle. Centered, soft shadow, clean lighting. Solid white background. No text, no logos, no transparency." | E-commerce product records |
| **Hero/listing image** | "Generate a 16:9 (landscape) hero listing image for a yoga class booking Genesis app: a minimal, calming scene with a yoga mat and plants. Solid warm-beige background, soft lighting. No text, no logos, no transparent areas." | Listing cards, hero sections |
| **Catalog set** | "Generate a set of eight 1:1 (square) consistent listing images of simple office items (notebooks, pen, laptop, coffee mug). Same camera angle and lighting. Solid light background. No text, no logos, no transparency." | Product catalogs, inventory |
### Backgrounds & Textures
| Use Case | Prompt | Best For |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------- |
| **Page background** | "Generate a 16:9 (landscape) subtle app page background with a solid deep-indigo base and extremely light paper-grain texture. No text, no icons, no transparent areas." | Full-page app backgrounds |
| **Dashboard bg** | "Generate a 16:9 (landscape) dashboard background with a solid charcoal base and faint low-contrast dot pattern. No text, no transparency." | Dashboard sections |
| **Theme pack** | "Generate four backgrounds: two 16:9 (landscape) and two 1:1 (square). Use a consistent minimal style with solid-color bases (navy/indigo/teal) and subtle textures. No text, no logos, no transparent background." | Multi-page apps |
### Icons & UI Elements
| Use Case | Prompt | Best For |
| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- |
| **Category icons** | "Generate a set of six 1:1 (square) flat-style category icons: settings gear, user profile, calendar, chart, message bubble, and folder. Consistent line weight, single accent color on white. No text." | Navigation, category cards |
| **Feature illustration** | "Generate a 1:1 (square) isometric illustration of a team collaborating around a digital dashboard. Flat colors, modern style. No text, no transparency." | Feature sections, onboarding |
| **Empty state** | "Generate a 1:1 (square) friendly illustration of an empty inbox with a smiling envelope. Soft pastel colors, minimal style. No text." | Empty/zero-state screens |
### Marketing & Branding
| Use Case | Prompt | Best For |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------ |
| **Social card** | "Generate a 16:9 (landscape) social media share image for a project management app. Clean, professional, with abstract geometric shapes in blue and white. No text, no logos." | Open graph / social sharing |
| **Banner** | "Generate a 16:9 (landscape) promotional banner with a modern gradient (blue to purple) and abstract wave patterns. Clean, premium feel. No text, no transparency." | App headers, promotional pages |
| **Favicon concept** | "Generate a 1:1 (square) minimal app icon concept: a simple geometric shape in deep blue on white background. Bold, recognizable at small sizes. No text." | Favicon, app icon reference |
***
## Image Generation Best Practices
| Practice | Why | Example |
| ----------------------------- | ------------------------------------ | ---------------------------------------------- |
| **Specify aspect ratio** | Prevents cropping issues | "1:1 (square)" or "16:9 (landscape)" |
| **State "No text"** | AI-generated text often has errors | Always include "No text, no logos" |
| **Request "No transparency"** | Ensures usable backgrounds | "Solid \[color] background" |
| **Use "consistent" for sets** | Keeps visual coherence across images | "Keep identical framing, lighting, and style" |
| **Describe lighting** | Controls mood and professionalism | "Studio lighting" or "Soft, natural lighting" |
| **Reference your brand** | Maintains consistency with your app | "Use our brand colors: navy #1a365d" |
| **Be specific about subject** | Reduces generation attempts | "Stainless-steel water bottle" not "a product" |
***
## What's Next
| Guide | What You'll Learn |
| --------------------------------------------------------------------------------------------- | ----------------------------------------- |
| [Adding Genesis Context](/taskade-genesis/genesis/adding-context) | Upload brand assets and design references |
| [Advanced Features](/taskade-genesis/space-apps-guide/advanced-features) | Customize app branding and appearance |
| [Publish and Clone Your Apps](/community-and-sharing/community-and-sharing/publish-and-clone) | Deploy your app with custom images |
| [Media AI Chat](/ai-features/ai-features/media-ai-chat) | Chat with media files and images using AI |
# Media AI Chat
Chat with your files, projects, and media in Taskade. Upload PDFs, images, CSVs, and videos, then ask questions, extract insights, and generate content with AI.
***
## Table of Contents
* [Overview](#overview)
* [Chat Methods](#chat-methods)
* [Method 1: Chat with Projects](#method-1-chat-with-projects)
* [Method 2: Chat with Projects & Team](#method-2-chat-with-projects-and-team)
* [Method 3: Chat with Attachments](#method-3-chat-with-attachments)
* [Method 4: Chat in Media Manager](#method-4-chat-in-media-manager)
* [Supported Media Types](#supported-media-types)
* [Use Cases](#use-cases)
* [Media & Workspace DNA](#media-and-workspace-dna)
* [What's Next](#whats-next)
***
## Overview
Media AI Chat lets you **have conversations with your files, projects, and media** using Taskade's AI. Upload documents, images, videos, or connect projects β then ask questions, extract insights, and generate content directly from your media.
> **Taskade Genesis connection:** Every file you upload to a Genesis app or discuss in Media AI Chat is stored in your workspace's Media library, enriching your [Workspace DNA](/taskade-genesis/genesis/how-genesis-works) and making all future apps and agents smarter.
***
## Chat Methods
### Method 1: Chat with Projects
Query your Taskade projects using natural language:
| Step | Action |
| ---- | ----------------------------------------------- |
| 1 | Open a project in Taskade |
| 2 | Click the **AI Chat** or **EVE** panel |
| 3 | Ask questions about the project content |
| 4 | AI responds using the project's data as context |
**Example queries:**
| Query | What AI Returns |
| --------------------------------- | ------------------------------------------------- |
| "Summarize this project" | A concise summary of all tasks, notes, and status |
| "What tasks are overdue?" | List of past-due items with details |
| "Who is assigned the most tasks?" | Team workload breakdown |
| "Generate a status report" | Formatted report based on project data |
### Method 2: Chat with Projects & Team
Collaborate with AI and team members in the same conversation:
| Step | Action |
| ---- | ------------------------------------------------------------ |
| 1 | Open a project's chat panel |
| 2 | Invite team members to the conversation |
| 3 | Ask AI questions β responses are visible to all participants |
| 4 | Team members can follow up, add context, or redirect the AI |
> **Tip:** Use this for collaborative analysis sessions β the AI provides data, your team discusses and decides.
### Method 3: Chat with Attachments
Upload files directly into a chat for instant AI analysis:
| Step | Action |
| ---- | ------------------------------------------------ |
| 1 | Open any AI chat (EVE, Agent, or Project chat) |
| 2 | Drag & drop files or click the attachment button |
| 3 | Ask questions about the uploaded file |
| 4 | AI analyzes the file content and responds |
**Example interactions:**
| File Type | Query | AI Response |
| --------------- | ----------------------------------------- | -------------------------------------- |
| **PDF report** | "What are the key findings?" | Summary of main points and conclusions |
| **CSV data** | "What trends do you see?" | Pattern analysis and insights |
| **Image** | "Describe what you see" | Visual analysis and description |
| **Spreadsheet** | "Which products have the highest margin?" | Data analysis with specific answers |
### Method 4: Chat in Media Manager
Access all workspace media in one place:
| Step | Action |
| ---- | ------------------------------------------------------------- |
| 1 | Open the **Media** tab in your workspace |
| 2 | Browse all uploaded files, generated images, and media assets |
| 3 | Click any media item to open it |
| 4 | Use AI chat to ask questions about the selected media |
***
## Supported Media Types
| Media Type | Formats | AI Capabilities |
| ----------------- | ----------------------------------------- | --------------------------------------------------- |
| **Documents** | PDF, DOCX, TXT, MD, PPTX, XLSX, CSV, EPUB | Full text analysis, summarization, Q\&A, extraction |
| **Images** | PNG, JPG, GIF, SVG, WebP | Visual description, content extraction, OCR |
| **Video** | YouTube URLs (via transcript) | Transcript analysis, key points extraction, Q\&A |
| **Web Content** | URLs, blog posts, articles | Content analysis, summarization, comparison |
| **Spreadsheets** | XLSX, CSV, Google Sheets | Data analysis, trend identification, reporting |
| **Presentations** | PPTX | Slide content analysis, outline extraction |
| **Social** | Tweets, Reddit posts, news articles | Sentiment analysis, summary, response drafting |
***
## Use Cases
| Use Case | How | Example |
| ------------------------ | ----------------------------------------- | ------------------------------------------------------------------ |
| **Document analysis** | Upload a report, ask questions | "What are the Q3 revenue figures from this financial report?" |
| **Data exploration** | Upload a CSV, ask for patterns | "Which customer segment has the highest churn rate in this data?" |
| **Content extraction** | Upload a PDF, extract structured data | "Extract all contact information from this business card scan" |
| **Image understanding** | Upload a screenshot, get description | "What UI elements are shown in this mockup?" |
| **Meeting prep** | Chat with project notes before a meeting | "Summarize the open items and blockers from last sprint's project" |
| **Competitive analysis** | Add competitor URLs, compare | "Compare the features listed on these two competitor pages" |
| **Knowledge building** | Upload training materials, quiz yourself | "Create 5 quiz questions from this training document" |
| **Report generation** | Chat with data, generate formatted output | "Create a monthly report from this spreadsheet data" |
***
## Media & Workspace DNA
Every media interaction enriches your workspace:
| Media Action | DNA Impact |
| --------------------------- | ---------------------------------------------------------------------- |
| Upload files to Genesis app | Added to Media library β available for future apps and agent knowledge |
| Generate images in chat | Saved to Media β reusable across all apps |
| Upload agent knowledge | Indexed for agent responses β better AI across workspace |
| Analyze documents | Insights inform future app builds |
| Chat with project data | Helps EVE understand your workspace patterns |
> **Cross-link:** Files uploaded in Media AI Chat can be used as [Genesis Context](/taskade-genesis/genesis/adding-context), [Agent Knowledge](/ai-features/ai-features/agent-knowledge), and as data sources for [Automations](/automations/automation).
***
## What's Next
| Guide | What You'll Learn |
| -------------------------------------------------------------------- | ------------------------------------------------- |
| [Adding Genesis Context](/taskade-genesis/genesis/adding-context) | Use media files as context for app building |
| [Agent Knowledge & Memory](/ai-features/ai-features/agent-knowledge) | Train agents on your media files |
| [Image Generation](/ai-features/ai-features/image-generation) | Generate new images to add to your media library |
| [Taskade AI Credits](https://www.taskade.com/learn/agents/ai-usage) | Understand credit usage for media AI interactions |
# Autopilot
Use Taskade Autopilot to turn one prompt into a full workspace of connected projects, AI agents, agent teams, and automations, then expand it or build apps.
***
## Table of Contents
* [Overview](#overview)
* [What Autopilot Creates](#what-autopilot-creates)
* [When to Use Autopilot](#when-to-use-autopilot)
* [Autopilot vs. Taskade Genesis](#autopilot-vs-genesis)
* [Tutorial: Use Autopilot](#tutorial-use-autopilot)
* [Expand Your Workspace](#expand-your-workspace)
* [Generate New Automations](#generate-new-automations)
* [Generate New AI Agents](#generate-new-ai-agents)
* [Generate New Projects](#generate-new-projects)
* [What's Next](#whats-next)
***
## Overview
Taskade Autopilot is a **workspace generation system** that transforms a single prompt into an entire interconnected ecosystem of projects, agents, and automations. Unlike traditional project management that requires manual setup, Autopilot constructs complete operational workspaces instantly.
> **Genesis connection:** Autopilot creates workspace ecosystems (projects + agents + automations). Genesis goes further β building full **deployable web applications** with UI, databases, and hosting. Together, they're the fastest way to build your complete Workspace DNA.
***
## What Autopilot Creates
From a single prompt, Autopilot generates:
| Component | What's Created | Example |
| --------------- | -------------------------------------------------------------- | ------------------------------------------------- |
| **Projects** | Multiple connected projects with task structures and timelines | Sprint board, backlog, docs, meeting notes |
| **AI Agents** | Specialized agents trained for workspace roles | Project Manager agent, QA agent, Copywriter agent |
| **Agent Teams** | Groups of agents that collaborate | Marketing team, Engineering team |
| **Automations** | Workflow flows connecting projects, agents, and tools | Daily standup β Slack, task completion β report |
***
## When to Use Autopilot
| Scenario | Why Autopilot Helps |
| ------------------------------ | ------------------------------------------------------------------------------------- |
| **New team setup** | Need complete operational structure with projects, agents, and workflows from day one |
| **Scattered workflows** | Current tools are disconnected β need a unified, interconnected workspace |
| **Urgent projects** | Need a full workspace running immediately for a new initiative |
| **Manual process replacement** | Want to replace repetitive processes with AI-driven automation |
| **Department onboarding** | Need a structured workspace for a new department or function |
***
## Autopilot vs. Genesis
| Feature | Autopilot | Genesis |
| ----------------------------- | -------------------------------------------------------- | -------------------------------------- |
| **What it creates** | Workspace ecosystem (projects + agents + automations) | Full deployable web application |
| **Output** | Interconnected Taskade workspace | Live app with UI, databases, hosting |
| **Use case** | Internal team operations | Customer-facing apps, tools, portals |
| **Deployment** | Instant workspace | Published URL + optional custom domain |
| **Intelligence Score impact** | Creates all 3 pillars (+projects, +agents, +automations) | Creates all 3 pillars + deployable app |
| **Best for** | "Set up my team's workspace" | "Build me an app for my customers" |
> **Use both:** Autopilot to create your operational workspace, Genesis to build customer-facing apps powered by that workspace.
***
## Tutorial: Use Autopilot
### Step-by-Step
| Step | Action |
| ---- | -------------------------------------------------------------------------------------------------------- |
| 1 | Click the **+** button in the left sidebar β **Create with AI** (or visit `taskade.com/create` directly) |
| 2 | Type a description of the workspace you need in the prompt bar |
| 3 | Click the arrow button or press **Enter** |
| 4 | Wait for Autopilot to generate: AI Agents, Teams, Projects, Automation Flows |
| 5 | Click **Deploy to Taskade** to add the workspace to your account |
### Example Prompts
| Prompt | What Autopilot Creates |
| ------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| "Set up a marketing team workspace" | Content calendar, campaign tracker, social scheduler, Copywriter agent, SEO agent, daily digest automation |
| "Create a dev sprint workspace" | Sprint board, backlog, bug tracker, QA agent, standup automation, GitHub integration |
| "Build an HR onboarding system" | Onboarding checklist, policy docs, new hire tracker, HR Assistant agent, welcome email automation |
| "Set up a sales outreach workspace" | Lead pipeline, outreach tracker, meeting notes, Sales agent, CRM automation |
| "Create a content calendar workspace" | Content calendar, editorial board, publishing tracker, Content Writer agent, social posting automation |
### Suggested Templates
Autopilot offers built-in templates for common use cases:
| Template | Description |
| ---------------- | -------------------------------------------------------- |
| Sales Outreach | Lead management, outreach sequences, CRM automation |
| Marketing | Content calendar, campaign tracking, social distribution |
| Dev Sprints | Sprint planning, backlog management, CI/CD integration |
| HR Onboarding | New hire flows, policy management, training tracking |
| Content Calendar | Editorial planning, publishing workflows, multi-channel |
***
## Expand Your Workspace
After Autopilot generates your initial workspace, expand it with these tools:
### Generate New Automations
| Step | Action |
| ---- | ------------------------------------------------ |
| 1 | Go to the **Automations** tab in your workspace |
| 2 | Click **Add automation** β **Generate With AI** |
| 3 | Describe what you want the automation to achieve |
| 4 | Choose a generator mode: |
| Mode | Description |
| ------------------- | ---------------------------------------------------------- |
| **Auto** (default) | AI selects the optimal mode for your task |
| **Agent Tool Mode** | Generates an automation as an AI agent tool |
| **Workflow Mode** | Standard project automation flow |
| **Form Mode** | Generates a smart form that triggers actions on submission |
| Step | Action |
| ---- | ------------------------------------- |
| 5 | Press Enter and wait for the result |
| 6 | Click **Create Automation** to add it |
| 7 | Customize and enable the automation |
### Generate New AI Agents
| Step | Action |
| ---- | -------------------------------------------------------------- |
| 1 | Go to the **Agents** tab |
| 2 | Click **Create agent** β **Generate** |
| 3 | **Option A:** Describe the agent you want |
| 4 | **Option B:** Choose from prompt examples |
| 5 | Press Enter and wait for generation |
| 6 | *(Optional)* Customize: Name, Instructions, Commands, Language |
| 7 | Click **Create & Launch Agent** |
### Generate New Projects
| Step | Action |
| ---- | --------------------------------------- |
| 1 | Click **+ Create new** β **AI Project** |
| 2 | Describe the project you want |
| 3 | *(Optional)* Configure output settings: |
| Setting | Options |
| ---------------- | ------------------------------------------------------------------ |
| **View** | Default project view (List, Board, Table, etc.) |
| **Language** | Output language |
| **Upload Files** | Seed documents (.pdf, .docx, .txt, .md, .pptx, .xlsx, .csv, .epub) |
| **Add Links** | Link to online resources |
| **Agent Mode** | Generate a default agent for the project |
| Step | Action |
| ---- | -------------------------------------------------------------------- |
| 4 | Press Enter to generate |
| 5 | Choose: **Create project**, **Continue writing**, or **Make longer** |
***
## What's Next
| Guide | What You'll Learn |
| ---------------------------------------------------------------- | ----------------------------------------- |
| [How Genesis Works](https://www.taskade.com/learn/genesis) | Build deployable apps from your workspace |
| [Workflow Generator](/automations/automation/workflow-generator) | Build automations with natural language |
| [Taskade for Teams](/workspaces/workspaces/teams) | Organize teams within your workspace |
# Automations Overview
Automate work 24/7 with Taskade's trigger-and-action engine β connect 100+ integrations and let AI agents run your workflows from start to finish.
Automations let you build trigger-and-action workflows that run on their own β connecting Taskade to your tools and letting agents act 24/7.
## I want toβ¦
| I want to⦠| Go to |
| ----------------------------------- | ------------------------------------------------------------------------------- |
| Build my first workflow | [Action & Trigger Reference](/automations/automation/actions) |
| Find available triggers and actions | [Action & Trigger Reference](/automations/automation/actions) |
| Generate a workflow from a prompt | [Workflow Generator](/automations/automation/workflow-generator) |
| Connect an integration | [Integration Overview](/automations/automation/comprehensive-integration-guide) |
| See every available connector | [Integration Options](/automations/automation/integrations) |
| Start from a ready-made recipe | [Automation Recipes](/automations/automation/recipes) |
**Act. Execute. Evolve.** Taskade Automations are the living motion layer of Workspace DNA, transforming static workflows into intelligent, adaptive systems that act with precision and learn from every execution.
{% hint style="success" %}
**Living Motion Layer** β Automations that don't just execute tasks, but learn from patterns, adapt to changing conditions, and continuously improve business outcomes.
{% endhint %}
## What is Living Motion?
Living Motion is Taskadeβs automation layer. Itβs how your workspace can **react**, **decide**, and **execute** when something happens.
Every automation follows the same shape: a trigger starts it, an optional condition routes it, and actions do the work.
```mermaid
flowchart TD
A["Trigger
schedule, form, webhook, or project event"] --> B{"Condition / Filter"}
B -->|matches| C["Actions"]
B -->|no match| E["Stop"]
C --> D["AI step
Taskade EVE classifies or drafts"]
C --> F["Integration
notify or sync a connected tool"]
C --> G["Update tasks in Taskade Genesis"]
D --> H["Result"]
F --> H
G --> H
```
Canonical foundation: [Workspace DNA](/platform/workspace-dna).
### What you use it for
* **Notifications**: send Slack/Teams/email alerts.
* **Routing**: assign work based on content, priority, or owner.
* **Sync**: keep CRMs, Sheets, and databases updated.
* **Reporting**: scheduled summaries and digests.
* **Approvals**: add a human-in-the-loop before publishing or sending.
### Core building blocks
#### Triggers
Triggers start workflows. Common ones are schedules, forms, webhooks, and project events.
#### Actions
Actions do work. Create tasks, update fields, call webhooks, send notifications, and more.
#### Conditions and branching
Use branches to route different cases. Example: urgent β page someone, normal β add to queue.
#### AI steps
Use an agent to classify, extract, or draft. Then route or act on the structured result.
### Getting started (fast)
1. Pick one workflow you want end-to-end.
2. Choose one trigger.
3. Add 1β3 actions.
4. Test with real data.
5. Add branching and AI only if needed.
### Typical workflows
* Form submission β classify β create task β notify channel
* Webhook β normalize data β update CRM β log result
* Schedule β build weekly summary β send digest
### Available Triggers
**Project Events:**
* **Task Added** β when a new task is created
* **Task Completed** β when a task is marked done
* **Task Assigned** β when a task is assigned to someone
* **Task Due** β when a task reaches its due date
* **New Comment** β when a comment is added
* **New Due Date** β when a due date is set
* **Custom Field Updated** β when a custom field value changes
* **Project Completed** β when all tasks are done
* **Public Agent Chat Ended** β when a public agent conversation finishes
* **Task Moved** β when a task moves from one project to another
* **Project Created** β when a new project is created in a space
* **Due Date Removed** β when a due date is cleared from a task
* **File Added to Media** β when a file is uploaded to the media library
**External Triggers:**
* **Webhook** β receive data from any external service via HTTP POST
* **Form** β custom input forms with text, email, date, and time fields
* **Schedule** β run every X minutes (sub-hourly intervals), hourly, daily, weekly, or monthly
* **Mailhook** β trigger from incoming emails
**Integration Triggers** (from connected services):
Calendly, Slack, Typeform, Gmail, Google Sheets, Google Forms, Google Drive, Webflow, HubSpot, Discord, GitHub, YouTube, RSS, Google Calendar
### 36 Integration Pieces
Connect your workflows to popular tools across the [Taskade integrations](https://www.taskade.com/integrations) directory.
| Category | Services |
| ---------------- | -------------------------------------------------------------------- |
| Communication | Slack, Discord, Microsoft Teams, WhatsApp Business, Telegram Bot |
| Email | Gmail, Mailchimp |
| Google Workspace | Sheets, Drive, Calendar, Docs, Forms |
| CRM & Sales | HubSpot, Apollo |
| E-Commerce | Shopify, Stripe |
| Social Media | X/Twitter, LinkedIn, Facebook Pages, Reddit, YouTube |
| Developer | GitHub, HTTP |
| Forms & CMS | Typeform, Webflow, WordPress |
| Scheduling | Calendly, Zoom |
| AI & Media | Web Search, Web Scraping, YouTube Transcription, Document Extraction |
| Utilities | Schedule, Delay, Loop, Branch, Filter |
### Where to go next
* Build your first workflow: [Actions & Triggers](/automations/automation/actions)
* Step catalog: [Actions & Triggers](/automations/automation/actions)
* Pick tools to connect: [Integration Overview](/automations/automation/comprehensive-integration-guide)
* Full list of connectors: [Integration Options](/automations/automation/integrations)
* **Let your agents reach external tools** (Slack, Stripe, Shopify, Gmail) via [MCP Connectors](/developers/mcp-connectors).
* Troubleshoot: [Living System Troubleshooting](/community-and-sharing/community-and-sharing/troubleshooting)
## Next steps
* [Action & Trigger Reference](/automations/automation/actions) β pick a trigger and add your first actions
* [Automation Recipes](/automations/automation/recipes) β start from a proven workflow
* [Integration Overview](/automations/automation/comprehensive-integration-guide) β connect the tools you already use
* [Living System Troubleshooting](/community-and-sharing/community-and-sharing/troubleshooting) β fix issues and get help
{% hint style="info" %}
This page stays overview-level. Deep trigger/action lists, templates, and advanced patterns live in the reference pages above.
{% endhint %}
# AI Forms
Build Taskade AI Forms with smart validation, sentiment analysis, and conditional questions that auto-route responses into your workspace and CRM.
**Create intelligent forms that think, adapt, and integrate seamlessly with your Taskade workspace. AI Forms go beyond traditional form builders by understanding context, validating responses intelligently, and automating follow-up actions.**
{% hint style="success" %}
**New to AI Forms?** Start with a simple feedback form and watch how AI transforms basic data collection into intelligent user experiences that learn and improve over time.
{% endhint %}
***
## What Makes AI Forms Special?
### **Traditional Forms vs. AI Forms**
| Feature | Traditional Forms | AI Forms |
| --------------------- | ----------------------------- | ----------------------------- |
| **Field Validation** | Basic rules (email, required) | Smart context validation |
| **User Experience** | Static questions | Dynamic, adaptive questions |
| **Data Processing** | Store raw responses | AI analysis + insights |
| **Follow-up Actions** | Manual review required | Automated intelligent routing |
| **Integration** | Basic webhook/email | Deep workspace integration |
### **Key AI Capabilities**
* **Smart Validation**: AI understands context and validates responses intelligently
* **Dynamic Questions**: Forms adapt based on previous answers
* **Sentiment Analysis**: Automatically detect tone and emotion in text responses
* **Auto-categorization**: Responses are automatically tagged and organized
* **Intelligent Routing**: AI determines the best next action for each submission
***
## Creating Your First AI Form
### **Step 1: Choose Your Creation Method**
#### **Option A: AI Generation (Recommended)**
```
"Create a customer satisfaction survey for my restaurant with:
- Star ratings for food quality, service speed, and atmosphere
- Optional text feedback section
- Photo upload for meal pictures
- Automatic thank you message
- If rating is below 3 stars, immediately notify manager via Slack"
```
#### **Option B: Form Builder Interface**
1. Go to your workspace **Automations** tab
2. Click **"Create automation flow"**
3. Add **"AI Forms"** as your trigger
4. Configure form settings and fields
5. Add automation actions for processing responses
### **Step 2: Configure Form Settings**
| Setting | Description | Example |
| ---------------------- | ---------------------------------------- | ------------------------------------------ |
| **Form Title** | Choose a unique title for your form | "Customer Feedback Survey" |
| **Form Description** | Describe the purpose of the form | "Help us improve your experience" |
| **Submit Button Text** | Choose a title for the submission button | "Submit Feedback" |
| **Form End Page** | Display an end screen with custom text | "Thank you! We'll respond within 24 hours" |
### **Step 3: Choose Form Fields**
AI Forms include customizable field types to collect different kinds of information:
| Field Type | Description | Best For | AI Enhancement |
| ------------------- | --------------------------------------- | ------------------------------- | ------------------------------------------ |
| **Short Text** | For short answers like a name or title | Names, titles, keywords | Auto-validation, spell check |
| **Long Text** | For longer answers like comments | Feedback, descriptions | Sentiment analysis, categorization |
| **Option Dropdown** | A list of choices where one is selected | Categories, preferences | Smart suggestions based on context |
| **Number** | For numbers like age or quantity | Ages, quantities, scores | Range validation, statistical analysis |
| **File** | Lets users upload files | Documents, images, attachments | Content analysis, OCR processing |
| **Phone** | For phone numbers | Contact information | Format validation, region detection |
| **Email** | For email addresses | Contact information | Domain validation, duplicate detection |
| **Date** | A calendar to pick a date | Appointments, deadlines | Smart date suggestions, conflict detection |
| **Rating** | For giving ratings (stars/numbers) | Satisfaction, quality scores | Trend analysis, alert thresholds |
| **Single-Select** | Allow one option from predefined list | Multiple choice questions | Response pattern analysis |
| **Multi-Select** | Allow multiple options | Interests, features, tags | Correlation analysis, preference mapping |
| **Checkbox** | A yes/no checkbox submitting true/false | Consent boxes, opt-ins, toggles | Branch or filter automations on the value |
| **URL** | Accept web addresses or links | Website links, references | Link validation, content preview |
### **Step 4: Configure AI-Powered Processing**
#### **Smart Rating Fields**
```yaml
Field Type: AI Rating
Configuration:
- Scale: 1-5 stars or 1-10 numeric
- AI Analysis: Sentiment correlation with text responses
- Auto-flagging: Ratings below threshold trigger alerts
- Visual: Star icons, thumbs up/down, or custom emojis
```
#### **Intelligent Text Fields**
```yaml
Field Type: AI Text Analysis
Configuration:
- Sentiment Detection: Positive, negative, neutral scoring
- Keyword Extraction: Automatic tag generation
- Language Detection: Multi-language form support
- Response Quality: AI flags incomplete or unclear responses
```
#### **Dynamic Question Logic**
```yaml
Field Type: Conditional AI Questions
Configuration:
- Trigger Conditions: Based on previous answers
- AI-Generated Follow-ups: Context-aware next questions
- Progressive Disclosure: Reveal questions as needed
- Smart Branching: AI determines optimal question path
```
### **Step 3: Set Up AI Processing Rules**
#### **Automatic Response Analysis**
```javascript
// Example AI processing configuration
{
"aiAnalysis": {
"sentiment": {
"enabled": true,
"thresholds": {
"negative": -0.5,
"positive": 0.5
}
},
"categorization": {
"enabled": true,
"categories": ["complaint", "compliment", "suggestion", "question"]
},
"urgency": {
"enabled": true,
"urgentKeywords": ["urgent", "asap", "emergency", "broken"]
}
}
}
```
#### **Smart Validation Rules**
```javascript
// AI-powered validation examples
{
"smartValidation": {
"emailField": {
"aiCheck": "Verify email domain exists and looks professional",
"suggestions": "Offer corrections for common typos"
},
"phoneField": {
"aiFormat": "Detect country and format appropriately",
"validation": "Check if number format is valid for detected country"
},
"textFields": {
"minQuality": "Ensure responses are complete and meaningful",
"languageDetect": "Auto-detect language and respond appropriately"
}
}
}
```
***
## Advanced Form Customization
### **Visual Design & Branding**
#### **Smart Theme Adaptation**
```css
/* AI automatically adapts these elements based on your workspace branding */
.ai-form-container {
--primary-color: var(--workspace-primary);
--accent-color: var(--workspace-accent);
--font-family: var(--workspace-font);
}
/* AI-generated responsive breakpoints */
@media (max-width: 768px) {
.ai-form-field {
font-size: 1.1em; /* AI optimizes for mobile readability */
}
}
```
#### **Dynamic Visual Elements**
* **Progress Indicators**: AI calculates optimal completion visualization
* **Smart Field Ordering**: AI reorders fields based on completion patterns
* **Contextual Help**: AI provides relevant hints based on user behavior
* **Accessibility Auto-enhancements**: AI adds ARIA labels and screen reader support
### **Multi-Step Forms with AI Logic**
#### **Smart Step Progression**
```yaml
Step Configuration:
Step 1: "Basic Information"
- AI determines required vs. optional fields
- Smart field pre-population from known data
Step 2: "Detailed Feedback"
- Only shown if Step 1 indicates detailed feedback needed
- AI generates contextual questions based on Step 1 responses
Step 3: "Follow-up Preferences"
- AI predicts user preferences based on response patterns
- Smart default selections
```
#### **Intelligent Completion Optimization**
* **Abandonment Prevention**: AI detects when users might leave and offers assistance
* **Smart Save & Resume**: AI automatically saves progress at optimal points
* **Completion Prediction**: AI estimates time remaining and adjusts accordingly
***
## Form Templates & Quick Start
### **Start with AI Form Templates**
Don't want to build forms from scratch? Choose from pre-built templates:
| Template Type | Use Case | Included Fields | Automation Actions |
| ---------------------- | -------------------------------- | --------------------------------------- | ---------------------------------------- |
| **Customer Feedback** | Collect product/service feedback | Rating, comments, contact info | Auto-categorize, notify team |
| **Lead Qualification** | Qualify potential customers | Company, budget, timeline | Score leads, assign to sales |
| **Support Ticket** | Technical support requests | Issue type, priority, description | Route to specialists, create tasks |
| **Event Registration** | Event sign-ups and RSVPs | Name, email, dietary restrictions | Send confirmations, update attendee list |
| **Job Application** | Collect job applications | Resume upload, experience, availability | Screen candidates, schedule interviews |
| **Survey Research** | Market research and surveys | Multiple choice, ratings, demographics | Analyze trends, generate reports |
### **Share and Use Forms**
Once your form is ready, you have multiple sharing options:
#### **Public Link Sharing**
* Get a direct URL to share via email, social media, or messaging
* Customize the form URL for branding consistency
* Track submission analytics and response rates in real-time
#### **Website Embedding**
```html
```
#### **Configure Form Visibility**
* **Public**: Anyone with the link can access
* **Workspace Only**: Restricted to team members
* **Password Protected**: Require password for access
* **Time-Limited**: Set expiration date for form availability
***
## Integration & Automation
### **Real-Time Workspace Integration**
#### **Automatic Project Creation**
```javascript
// Form submissions automatically create structured data
{
"formSubmission": {
"source": "Customer Feedback Form",
"autoActions": [
{
"type": "createProject",
"template": "feedback-analysis",
"data": {
"customer": "{{form.name}}",
"rating": "{{form.overall_rating}}",
"sentiment": "{{ai.sentiment_score}}",
"category": "{{ai.auto_category}}",
"priority": "{{ai.calculated_priority}}"
}
}
]
}
}
```
#### **AI Agent Collaboration**
```yaml
Agent Integration:
- Response Analysis: AI agent reviews all submissions
- Quality Scoring: Agent rates response completeness and clarity
- Follow-up Suggestions: Agent recommends next actions
- Pattern Recognition: Agent identifies trends across submissions
```
### **External Service Integration**
#### **CRM Synchronization**
```javascript
{
"crmSync": {
"service": "hubspot", // or "salesforce", "pipedrive", etc.
"mapping": {
"contact": {
"email": "{{form.email}}",
"name": "{{form.full_name}}",
"company": "{{form.company}}"
},
"deal": {
"value": "{{ai.estimated_deal_size}}",
"stage": "{{ai.qualification_stage}}",
"priority": "{{ai.lead_score}}"
}
},
"aiEnhancements": {
"leadScoring": "AI calculates lead quality score",
"nextBestAction": "AI suggests optimal follow-up timing and method"
}
}
}
```
#### **Communication Automation**
```yaml
Smart Notifications:
High Priority (AI Score > 8):
- Immediate Slack notification to sales team
- SMS alert to designated manager
- Calendar event created for follow-up call
Medium Priority (AI Score 5-8):
- Email summary to team lead
- Task created in project management system
- Follow-up scheduled for next business day
Low Priority (AI Score < 5):
- Added to weekly digest
- Automated thank you email sent
- Data stored for trend analysis
```
***
## Analytics & Insights
### **AI-Powered Form Analytics**
#### **Completion Intelligence**
* **Drop-off Analysis**: AI identifies where users abandon forms and suggests improvements
* **Time-to-Complete Optimization**: AI recommends form length adjustments
* **Field Performance**: AI ranks which fields provide the most valuable data
* **User Experience Scoring**: AI rates overall form usability
#### **Response Quality Metrics**
```javascript
{
"qualityMetrics": {
"completeness": "Percentage of meaningful responses",
"sentiment": "Overall emotional tone of submissions",
"actionability": "How many responses led to concrete actions",
"engagement": "Time spent and interaction depth per submission"
}
}
```
### **Smart Reporting Dashboard**
#### **Auto-Generated Insights**
* **Weekly Intelligence Reports**: AI summarizes key trends and patterns
* **Anomaly Detection**: AI flags unusual response patterns
* **Predictive Analytics**: AI forecasts response volumes and trends
* **Actionable Recommendations**: AI suggests form improvements and process optimizations
***
## Technical Implementation
### **Embedding Options**
#### **Direct Website Embed**
```html
```
#### **React Component Integration**
```jsx
import { TaskadeAIForm } from '@taskade/ai-forms-react';
function ContactPage() {
return (
{
console.log('Form data:', data);
console.log('AI insights:', aiInsights);
}}
aiConfig={{
realTimeValidation: true,
smartSuggestions: true,
sentimentAnalysis: true
}}
/>
);
}
```
### **API Access**
#### **Form Data**
AI Forms does not currently expose a public REST API for reading submissions in API v1 (there is no `/forms` endpoint). To work with submission data programmatically, capture it with an **automation** when a form is submitted β route responses into a project, forward them to an external service via the HTTP/Webhook action, or hand them to an agent. See [Webhooks](/developers/webhooks) and the [Action & Trigger Reference](/automations/automation/actions).
### **Webhook Integration**
```javascript
// Receive real-time form submissions with AI insights
app.post('/taskade-form-webhook', (req, res) => {
const { submission, aiAnalysis } = req.body;
// AI automatically provides:
// - Sentiment analysis
// - Category classification
// - Priority scoring
// - Suggested next actions
if (aiAnalysis.priority === 'high') {
// Immediate action required
sendSlackAlert(submission);
createUrgentTask(submission);
}
res.status(200).send('OK');
});
```
***
## Best Practices & Tips
### **Form Design Optimization**
#### **AI-Driven UX Principles**
* **Progressive Disclosure**: Start with essential fields, let AI determine when to reveal more
* **Smart Defaults**: Use AI to pre-populate fields based on user context
* **Contextual Help**: AI provides assistance exactly when and where users need it
* **Adaptive Layout**: AI adjusts form layout based on device and user behavior patterns
#### **Response Quality Enhancement**
* **Question Clarity**: AI analyzes question comprehension and suggests improvements
* **Response Validation**: AI ensures responses are complete and meaningful
* **Follow-up Optimization**: AI determines the best questions to ask next
* **Abandonment Prevention**: AI detects frustration signals and offers help
### **Data Privacy & Security**
#### **AI-Enhanced Privacy Controls**
* **Smart Data Classification**: AI automatically identifies and protects sensitive information
* **Consent Management**: AI ensures proper consent collection for data processing
* **Retention Optimization**: AI suggests optimal data retention periods
* **Anonymization**: AI can automatically anonymize responses while preserving insights
### **Performance Optimization**
#### **Loading Speed & Responsiveness**
* **Lazy Loading**: AI determines optimal field loading sequence
* **Caching Strategy**: AI-powered caching for faster form delivery
* **Mobile Optimization**: AI ensures perfect mobile experience across devices
* **Accessibility**: AI automatically adds accessibility enhancements
***
## Real-World Examples
### **Customer Feedback Survey**
```yaml
Use Case: Restaurant feedback collection
AI Features:
- Photo analysis of meal images
- Sentiment analysis of written feedback
- Automatic routing of complaints to managers
- Trend analysis of service quality over time
Results:
- 40% increase in response rates
- 60% faster issue resolution
- Automated insights reduce manual analysis time by 80%
```
### **Lead Generation Form**
```yaml
Use Case: B2B lead qualification
AI Features:
- Company information auto-completion
- Lead scoring based on responses
- Optimal follow-up timing prediction
- Integration with sales CRM
Results:
- 35% improvement in lead quality
- 50% reduction in qualification time
- 25% increase in conversion rates
```
### **Event Registration System**
```yaml
Use Case: Conference attendee registration
AI Features:
- Smart session recommendations based on interests
- Dietary restriction and accessibility auto-detection
- Networking match suggestions
- Capacity management optimization
Results:
- 45% higher attendee satisfaction scores
- 30% more meaningful networking connections
- 90% reduction in manual coordination tasks
```
***
## Troubleshooting & Support
### **Common Issues & Solutions**
#### **AI Analysis Not Working**
* **Check API Limits**: Ensure you haven't exceeded AI processing quotas
* **Validate Form Configuration**: Confirm AI features are properly enabled
* **Response Quality**: AI requires meaningful text responses for analysis
* **Language Support**: Verify AI supports the language of responses
#### **Integration Problems**
* **Webhook Validation**: Ensure webhook endpoints are properly configured
* **Data Mapping**: Verify field mapping between form and destination system
* **Authentication**: Check API tokens and permissions
* **Rate Limits**: Monitor API usage and implement proper error handling
### **Getting Help**
* **Documentation**: [Taskade Developer API](/developers/developer-home)
* **Community**: [AI Forms Discussion Forum](https://community.taskade.com/ai-forms)
* **Support**: Contact support for advanced AI configuration assistance
* **Templates**: Browse pre-built AI form templates in your workspace
***
**π Ready to transform your data collection with AI?** Start with a simple feedback form and discover how artificial intelligence can make every form submission more valuable and actionable.
*For more advanced AI integrations, explore our* [*AI Agents documentation*](/ai-features/ai-features/ai-agents-getting-started) *and* [*Automation workflows*](/automations/automation)*.*
# Action & Trigger Reference
Complete Taskade automation action reference: create tasks, run AI agents, send HTTP requests, connect Slack and GitHub, and chain steps into workflows.
Actions are the tasks that automations can perform. Each action connects to a specific service or system to create, update, or retrieve data. Actions can be chained together to create complex workflows.
## Overview
Actions are the "then" part of automation workflows - the tasks that get performed when trigger conditions are met. Taskade provides a comprehensive set of actions that can create projects, manage tasks, interact with AI, integrate with external services, and perform complex data operations.
{% hint style="success" %}
Actions can be chained together to create complex multi-step workflows, with conditional logic and data transformation capabilities that enable truly intelligent automation.
{% endhint %}
## Complete Action Reference
### Taskade Core Actions
| Action | Description | Use Case | Parameters |
| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ | ----------------------------------------------------------------- |
| **Create Project** | Sets up a new project in your workspace/folder | Project initialization, template-based workflows | `name`, `folderId`, `template`, `defaultView` |
| **Add Task** | Adds a new task to an existing project | Task creation workflows, issue tracking | `projectId`, `title`, `content`, `assignee`, `dueDate` |
| **Mark Task as Completed** | Automatically marks a task as done | Status updates, completion workflows | `taskId`, `completedBy`, `completionNote` |
| **Create Project From Template** | Uses a pre-defined or custom template | Standardized project setup | `templateId`, `name`, `folderId` |
| **Move Task** | Moves a task to a different space | Workflow progression, categorization | `taskId`, `targetProjectId`, `position` |
| **Assign Task** | Assigns a task to someone | Work distribution, team management | `taskId`, `userId`, `notifyAssignee` |
| **Ask AI** | Uses AI to answer questions | Information retrieval, analysis | `query`, `context`, `model` |
| **Generate with AI** | Uses AI to generate content or responses | Content creation, drafting | `prompt`, `style`, `length` |
| **Respond with AI** | Automatically provides AI-generated responses | Automated communication | `input`, `tone`, `format` |
| **Ask Agent** | Uses a custom AI agent to respond to a query | Specialized AI interactions | `agentId`, `query`, `parameters` |
| **Run Agent Command** | Uses a custom AI agent command | Agent-driven automation | `agentId`, `command`, `input` |
| **Add Knowledge to Agent** | Transcribes knowledge and adds it as knowledge to an agent | Agent training, content integration | `agentId`, `content`, `source` |
| **Add Project to Agent Knowledge** | Automatically trains your AI agents with project content | Agent enhancement, knowledge management | `agentId`, `projectId`, `scope` |
| **Ask Agent With Structured Output** | Structures the output of agent replies | Standardized AI responses | `agentId`, `query`, `outputFormat` |
| **task.addComment** | Appends a comment to an existing task node | Audit trails, team communication on tasks | `taskId`, `comment` |
| **task.update** | Updates a task node's content or note field | Inline edits, AI-driven content rewrites | `taskId`, `content`, `note` |
| **task.get** | Reads a task node and returns its current data | Conditional logic, data-driven downstream steps | `taskId` |
| **project.getInfo** | Reads project metadata (name, dates, member list, etc.) | Dynamic references to project context in flows | `projectId` |
| **task.attachFile** | Attaches a file to a task node (returns `attachmentId`, `fileId`, `projectId`, `nodeId`, `filename`, `mimetype`) | Save uploads or generated files onto a task | `projectId` (Project), `nodeId` (Task ID, UUID), `fileUrl` (File) |
### Data Processing & Integration Actions
| Action | Description | Use Case | Parameters |
| ------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------------- | ------------------------------------------------- |
| **Scrape Webpage** | Extract the contents of a web page | Content aggregation, research | `url`, `selectors`, `format` |
| **Convert File to Text** | Convert a source file into text | Document processing, content extraction | `fileId`, `outputFormat`, `encoding` |
| **Transcribe YouTube Video** | Turn a YouTube video into text | Content creation, accessibility | `videoUrl`, `language`, `format` |
| **Transcribe Audio to Project** | Convert uploaded audio into project text | Meeting notes, voice memos, podcast indexing | `fileId`, `language`, `outputFormat` |
| **Upload File to Media** | Upload file through a URL to save in your workspace or folder's media tab | Media management, content storage | `url`, `fileName`, `folderId` |
| **Send HTTP Request** | Makes an API request to an endpoint; authentication is optional per call | External integrations, data synchronization | `method`, `url`, `headers`, `body`, optional auth |
| **Search Web** | Searches the web for information to add to a project or for the AI to analyze | Research automation, content enrichment | `query`, `sources`, `maxResults` |
{% hint style="info" %}
**Scanned documents work too.** Convert File to Text now falls back to **vision OCR** when a file has no machine-readable text β scanned PDFs, image-only documents, and photos of pages are transcribed automatically. OCR runs count toward your workspace's AI usage.
{% endhint %}
### Workflow Control Actions
| Action | Description | Use Case | Parameters |
| ----------------------------- | ----------------------------------------------------------------------------- | --------------------------------------- | ----------------------------------------------- |
| **Loop** | Iterates data tasks | Batch processing, data transformation | `dataSource`, `iterationLogic`, `maxIterations` |
| **Filter Data** | Performs actions only when the data meets a certain condition | Conditional processing, data validation | `condition`, `dataSource`, `filterCriteria` |
| **Branch** | Creates different paths within your workflow, depending on certain conditions | Decision trees, conditional logic | `condition`, `truePath`, `falsePath` |
| **Transform Array to String** | Converts the output of Find Task(s) and Find Row(s) actions into text | Data formatting, reporting | `arrayInput`, `template`, `separator` |
| **flow\.run** | Runs a saved flow as a depth-guarded subflow (prevents infinite recursion) | Reusable sub-flows, modular automation | `flowId`, `input`, `maxDepth` |
### Advanced Actions
| Action | Description | Use Case | Parameters |
| ------------------------ | ----------------------------------------- | -------------------------------- | ------------------------------------------- |
| **Update Custom Fields** | Updates custom fields within projects | Data management, status tracking | `taskId`, `fieldId`, `value`, `projectId` |
| **Find Task(s)** | Searches for tasks within projects | Task retrieval, reporting | `projectId`, `searchCriteria`, `maxResults` |
| **Delay** | Adds a time delay to automation workflows | Timing control, scheduling | `duration`, `unit` |
## Core Taskade Actions
### Project & Task Management
| Action | Description | Parameters | Example |
| -------------------------------- | ---------------------------------------------- | ------------------------------------------------------ | ------------------------------------------------ |
| **Create Project** | Sets up a new project in your workspace/folder | `name`, `folderId`, `template`, `defaultView` | Create "Customer Feedback" project from template |
| **Create Project From Template** | Uses a pre-defined or custom template | `templateId`, `name`, `folderId` | Create project from "Support Workflow" template |
| **Add Task** | Adds a new task to an existing project | `projectId`, `title`, `content`, `assignee`, `dueDate` | Add task "Review feedback #123" |
| **Mark Task as Completed** | Automatically marks a task as done | `taskId`, `completedBy`, `completionNote` | Mark task complete with resolution note |
| **Move Task** | Moves a task to a different project/space | `taskId`, `targetProjectId`, `position` | Move to "Processed" project |
| **Assign Task** | Assigns a task to someone | `taskId`, `userId`, `notifyAssignee` | Assign to support specialist with notification |
| **Update Custom Fields** | Updates custom fields within projects | `taskId`, `fieldId`, `value`, `projectId` | Set priority to "High", status to "In Progress" |
| **Find Task(s)** | Searches for tasks within projects | `projectId`, `searchCriteria`, `maxResults` | Find all tasks assigned to user |
### Find Task(s) Automation Settings
{% hint style="info" %}
The Find Task(s) action enables dynamic task retrieval within automation workflows. Search, filter, and process tasks based on specific criteria to create intelligent, data-driven automations.
{% endhint %}
#### When to Use Find Tasks
**Perfect for:**
* **Bulk processing** - Handle multiple tasks at once
* **Conditional workflows** - Process tasks meeting specific criteria
* **Reporting** - Generate summaries of task collections
* **Data synchronization** - Keep external systems updated
* **Quality control** - Identify tasks needing attention
#### Search Criteria Options
| Field | Conditions | Value Type | Example |
| --------------------- | -------------------------------------------------------------------------------------- | ---------------- | ------------- |
| **Task Created At** | Before, After, Empty, Not Empty | Date | `2024-01-01` |
| **Task Completed At** | Before, After, Empty, Not Empty | Date | `2024-01-15` |
| **Task Content** | Contains, Not Contains, Matches, Not Matches, Starts With, Ends With, Empty, Not Empty | Text | `"urgent"` |
| **Task Status** | Equals, Not Equals | Status | `"completed"` |
| **Assignee** | Equals, Not Equals, Empty, Not Empty | User | `"john.doe"` |
| **Due Date** | Before, After, Empty, Not Empty | Date | `today()` |
| **Custom Fields** | Various conditions based on field type | Depends on field | `"high"` |
#### Output Data Structure
**Task Object Properties:**
```json
{
"id": "task_123",
"name": "Complete project proposal",
"content": "Detailed task description",
"assignee": "user@example.com",
"due_date": "2024-01-15T10:00:00Z",
"status": "in_progress",
"created_at": "2024-01-10T09:00:00Z",
"completed_at": null,
"custom_fields": {
"priority": "high",
"category": "sales"
}
}
```
#### Find Tasks Use Cases
| Use Case | Automation Flow | Business Impact |
| --------------------------- | ------------------------------------------------------------- | --------------------------- |
| **Overdue Task Alerts** | Schedule β Find Tasks (overdue) β Send Email | Fewer missed deadlines |
| **Weekly Progress Reports** | Schedule β Find Tasks (completed this week) β Generate Report | Better project visibility |
| **Workload Balancing** | Schedule β Find Tasks (by assignee) β Reassign Tasks | Optimized team productivity |
| **Quality Assurance** | Schedule β Find Tasks (missing details) β Flag for Review | Improved task quality |
| **Performance Analytics** | Schedule β Find Tasks (by criteria) β Update Dashboard | Data-driven insights |
#### Advanced Filtering Examples
**Find High-Priority Overdue Tasks:**
```
Project: "Active Projects"
Filters:
- Priority Custom Field = "high"
- Due Date < today()
- Status β "completed"
```
**Find Tasks Assigned to Specific Team:**
```
Project: "Team Tasks"
Filters:
- Assignee contains "@company.com"
- Created At > last_week()
- Status = "in_progress"
```
**Find Tasks with Missing Information:**
```
Project: "All Projects"
Filters:
- Due Date is empty
- Assignee is empty
- Custom Field "Priority" is empty
```
#### Integration with Other Actions
**Find Tasks + Loop Processing:**
```
Find Tasks β Loop β Process Each Task β Update Status
```
**Find Tasks + Conditional Actions:**
```
Find Tasks β Branch (if count > 10) β Send Alert
```
**Find Tasks + Data Export:**
```
Find Tasks β Transform Array β Export to CSV
```
#### Best Practices
* **Limit result sets** to prevent performance issues (max 1000 tasks)
* **Use specific filters** to narrow down results efficiently
* **Combine with sorting** for predictable processing order
* **Handle empty results** gracefully in your workflows
* **Test with small datasets** before scaling to large projects
***
### Custom Fields Automation Settings
{% hint style="info" %}
The Update Custom Fields action allows you to automatically update custom fields in projects, ensuring your task data stays current without manual updates.
{% endhint %}
**Available Parameters:**
* **PROJECT ID**: ID of the target project
* **TASK ID**: ID of the task you want to update
* **FIELDS**: Add fields that should be updated with their new values
**Example Usage:**
```json
{
"action": "Update Custom Fields",
"projectId": "proj_123",
"taskId": "task_456",
"fields": {
"priority": "High",
"status": "In Progress",
"dueDate": "2024-01-15"
}
}
```
**Related Triggers:**
* Custom Field Updated (Automation Trigger)
* Task Added
* Task Completed
### Agent Commands
| Action | Description | Parameters | Example |
| ------------------------------------ | --------------------------------------------------- | ---------------------------------- | --------------------------------------------------- |
| **Ask AI** | Uses AI to answer questions | `question`, `context`, `model` | "What's the priority of this ticket?" |
| **Generate with AI** | Uses AI to generate content or responses | `prompt`, `contentType`, `length` | Generate email response to customer |
| **Respond with AI** | Automatically provides AI-generated responses | `input`, `responseType`, `tone` | Auto-respond to common inquiries |
| **Ask Agent** | Uses a custom AI agent to respond to a query | `agentId`, `question`, `context` | Query specialized support agent |
| **Run Agent Command** | Uses a custom AI agent command | `agentId`, `commandId`, `input` | Run "analyze\_sentiment" command |
| **Ask Agent With Structured Output** | Structures the output of agent replies | `agentId`, `query`, `outputSchema` | Get JSON response with specific fields |
| **Add Project to Agent Knowledge** | Automatically trains AI agents with project content | `agentId`, `projectId` | Keep agents updated with latest project information |
{% hint style="info" %}
**Taskade Genesis self-assembly capability:** Flows can programmatically assemble and configure agents at runtime β this is the mechanism that powers Genesis self-assembly features. If you are building advanced Genesis flows, check the in-app action picker for current availability of agent-assembly steps; the exact surface exposed to automation builders may vary by plan.
{% endhint %}
### Ask Agent With Structured Output Settings
{% hint style="info" %}
The Ask Agent With Structured Output action extracts specific information from AI agent responses and formats it as structured data that can be used as variables in subsequent automation steps.
**BYOK support:** When a Bring Your Own Key (BYOK) model is configured on the target agent, the one-shot structured-output path honors that key, so inference runs against your own API account rather than Taskade's shared quota.
{% endhint %}
#### When to Use Structured Output
**Perfect for:**
* Extracting specific data points from unstructured text
* Converting AI responses into usable variables
* Filling spreadsheet columns automatically
* Creating conditional logic based on AI analysis
* Standardizing data formats across automations
#### Output Schema Types
| Type | Description | Example Use Case |
| ----------------- | ------------------------------ | ------------------------------------------- |
| **String** | Text data | Extract product names, titles, descriptions |
| **Number** | Numeric values | Calculate costs, scores, percentages |
| **Boolean** | True/false values | Check conditions, validate data |
| **Date** | Date values | Extract deadlines, schedule dates |
| **Single Select** | Choose from predefined options | Status: "pending", "approved", "rejected" |
#### Structured Output Use Cases
| Use Case | Automation Flow | Example |
| ----------------------- | --------------------------------------------- | ----------------------------------------- |
| **Cost Analysis** | Task Added β Ask Agent β Update Fields | Calculate budget variance automatically |
| **Lead Qualification** | Form Submitted β Ask Agent β Route Lead | Score and qualify incoming leads |
| **Content Scoring** | Task Added β Ask Agent β Update Status | Rate content quality and assign reviewers |
| **Performance Metrics** | Schedule β Ask Agent β Update Dashboard | Calculate completion rates and KPIs |
| **Approval Routing** | Task Created β Ask Agent β Conditional Action | Route tasks based on AI evaluation |
#### Example Schema Configuration
```json
{
"output_schema": {
"priority_score": {
"type": "number",
"description": "Rate priority from 1-10"
},
"category": {
"type": "single_select",
"options": ["urgent", "normal", "low"],
"description": "Task priority category"
},
"needs_review": {
"type": "boolean",
"description": "Whether task requires additional review"
}
}
}
```
**Pro Tips:**
* Use descriptive field names that match your workflow
* Include clear descriptions for better AI understanding
* Test schemas with sample data before deploying
* Combine with conditional actions for powerful automation flows
***
| Action | Description | Parameters | Example |
| ------------- | ------------------------------------ | ---------------------------------------- | ----------------------------------------------- |
| **Prompt AI** | Give the model detailed instructions | `prompt`, `systemMessage`, `temperature` | Custom AI processing with specific instructions |
### Add Project to Agent Knowledge Automation Settings
{% hint style="info" %}
The Add Project to Agent Knowledge action automatically trains AI agents with project content, enabling context-aware responses and keeping agents updated with the latest information.
{% endhint %}
#### When to Use Add Project to Agent Knowledge
**Perfect for:**
* **Training agents on new work** - Keep agents current with project information
* **Enabling context-aware responses** - Allow agents to reference specific project details
* **Supporting onboarding** - Feed previous projects to help new team members
* **Powering research assistants** - Make agents smarter with research project content
* **Preparing for launches** - Train agents on feature launch or campaign plans
#### Add Project to Agent Knowledge Parameters
| Parameter | Description | Example |
| --------------------------- | ----------------------------------------------- | ---------------------------------- |
| **Agent ID** | ID of the AI agent to train | `agent_123456` |
| **Project ID** | ID of the project to add to knowledge | `proj_789012` |
| **Include Completed Tasks** | Whether to include completed tasks (true/false) | `true` |
| **Content Types** | Types of content to include | `tasks`, `comments`, `attachments` |
#### Add Project to Agent Knowledge Use Cases
| Use Case | Automation Flow | Business Impact |
| -------------------------- | ---------------------------------------------------------------- | ------------------------------------------ |
| **New Project Onboarding** | Project Created β Add Project to Agent β Welcome Message | Instant agent training for new initiatives |
| **Research Assistant** | Project Updated β Add Project to Agent β Enable Queries | Context-aware research support |
| **Customer Support** | Project Completed β Add Project to Agent β Update Knowledge Base | Enhanced support with project insights |
| **Team Collaboration** | Task Added β Add Project to Agent β Notify Team | Improved team coordination |
| **Knowledge Management** | Schedule β Add Project to Agent β Update Documentation | Automated knowledge base maintenance |
#### Integration Examples
**Automated Agent Training:**
```
Trigger: Project Created
Action: Add Project to Agent Knowledge
Action: Send Channel Message (Agent trained on new project)
Result: Agents immediately knowledgeable about new projects
```
**Research Project Updates:**
```
Trigger: Project Updated
Action: Add Project to Agent Knowledge
Action: Ask Agent (Summarize new findings)
Action: Update Dashboard (With insights)
Result: Real-time research insights and summaries
```
**Launch Preparation:**
```
Trigger: Task Added (To launch project)
Action: Add Project to Agent Knowledge
Action: Ask Agent (Generate FAQ)
Action: Send Email (Team preparation)
Result: Comprehensive launch support and documentation
```
#### Best Practices
* **Strategic Timing** - Add projects when they're most relevant to agent needs
* **Content Filtering** - Choose specific content types to avoid information overload
* **Regular Updates** - Schedule periodic knowledge refreshes for evolving projects
* **Agent Specialization** - Create dedicated agents for different project types
* **Performance Monitoring** - Track agent response quality after knowledge updates
***
### Data Processing & Utilities
| Action | Description | Parameters | Example |
| ------------------ | ---------------------------------- | --------------------------- | ----------------------------------------- |
| **Scrape Webpage** | Extract the contents of a web page | `url`, `selector`, `format` | Extract product info from competitor site |
### Scrape Webpage Automation Settings
{% hint style="info" %}
The Scrape Webpage action enables automated data extraction from websites. Perfect for competitor monitoring, market research, lead generation, and price tracking without manual data collection.
{% endhint %}
#### When to Use Scrape Webpage
**Perfect for:**
* **Competitor monitoring** - Track pricing, products, and promotions
* **Market research** - Gather data from multiple sources automatically
* **Lead generation** - Extract contact information from directories
* **Price monitoring** - Track product prices across e-commerce sites
* **Content aggregation** - Collect news, reviews, and industry updates
#### Scrape Webpage Parameters
| Parameter | Description | Example |
| --------------- | ----------------------------------- | ------------------------------------- |
| **URL** | Target webpage URL to scrape | `https://competitor.com/products` |
| **Selectors** | CSS selectors for specific elements | `.price`, `.product-title`, `.review` |
| **Max Results** | Limit number of extracted items | 10, 50, 100 |
| **Wait Time** | Delay before scraping (seconds) | 2, 5, 10 |
| **User Agent** | Browser identification string | Desktop Chrome, Mobile Safari |
| **Headers** | Custom HTTP headers | Authorization, Accept-Language |
#### Scrape Webpage Use Cases
| Use Case | Automation Flow | Business Impact |
| ----------------------- | ---------------------------------------------------------------------- | ---------------------------------- |
| **Competitor Analysis** | Schedule β Scrape Webpage β Analyze with AI β Update Dashboard | Real-time competitive intelligence |
| **Price Monitoring** | Schedule β Scrape Webpage β Compare Prices β Send Alerts | Dynamic pricing optimization |
| **Lead Generation** | Task Added β Scrape Webpage β Extract Contacts β Create Leads | Automated prospect discovery |
| **Market Research** | Schedule β Scrape Webpage β Aggregate Data β Generate Reports | Comprehensive market insights |
| **Content Monitoring** | Schedule β Scrape Webpage β Categorize Content β Update Knowledge Base | Current industry awareness |
#### Integration Examples
**Competitor Price Monitoring:**
```
Trigger: Schedule (Daily)
Action: Scrape Webpage (Competitor Pricing Page)
Action: Extract Prices with Selectors
Action: Compare with Your Prices
Action: Send Slack Alert (If Significant Changes)
Result: Automated competitive pricing intelligence
```
**Lead Generation from Directories:**
```
Trigger: Task Added (Industry Research)
Action: Scrape Webpage (Industry Directory)
Action: Extract Company Details
Action: Categorize with AI (Lead Qualification)
Action: Create Tasks (Follow-up Actions)
Result: Automated lead discovery and qualification
```
**Market News Aggregation:**
```
Trigger: Schedule (Hourly)
Action: Scrape Webpage (Industry News Sites)
Action: Extract Article Headlines
Action: Categorize with AI (Topic Classification)
Action: Add to Knowledge Base
Result: Current industry news awareness
```
#### Output Data Structure
**Scraped Content Format:**
```json
{
"url": "https://example.com/products",
"title": "Product Catalog",
"content": {
"text": "Full page text content...",
"html": "HTML structure...
",
"structured_data": {
"products": [
{
"name": "Product A",
"price": "$99.99",
"description": "Product description..."
}
]
}
},
"metadata": {
"scraped_at": "2024-01-15T10:30:00Z",
"response_time": 1.2,
"content_length": 15432
}
}
```
#### Advanced Scraping Techniques
**CSS Selector Strategies:**
* **Element Selection**: `div.product-card` - Select product containers
* **Attribute Extraction**: `img[src]` - Get image URLs
* **Text Content**: `.description::text` - Extract text only
* **Multiple Elements**: `.price, .old-price` - Select multiple elements
**JavaScript-Heavy Sites:**
* **Wait for Elements**: Delay scraping until dynamic content loads
* **Scroll Handling**: Simulate scrolling for infinite scroll pages
* **AJAX Detection**: Wait for asynchronous content to load
#### Best Practices
* **Respect robots.txt** and website terms of service
* **Use appropriate delays** between requests to avoid overloading servers
* **Handle dynamic content** with proper wait times and selectors
* **Monitor scraping success** rates and adjust selectors as needed
* **Cache results** appropriately to reduce unnecessary requests
* **Implement error handling** for network issues and site changes
#### Legal and Ethical Considerations
* **Terms of Service**: Review and comply with website terms
* **Rate Limiting**: Avoid overwhelming target servers
* **Data Usage**: Ensure compliance with data protection regulations
* **Attribution**: Properly credit sources when using scraped content
* **Fair Use**: Use scraped data responsibly and ethically
| Action | Description | Parameters | Example |
| ------------------------------- | ---------------------------------------- | ------------------------------------------- | ------------------------------------- |
| **Convert File to Text** | Convert a source file into text | `fileUrl`, `fileType`, `extractImages` | Convert PDF manual to searchable text |
| **Transcribe YouTube Video** | Turn a YouTube video into text | `videoUrl`, `language`, `includeTimestamps` | Create transcript of training video |
| **Transcribe Audio to Project** | Convert uploaded audio into project text | `fileId`, `language`, `outputFormat` | Turn voice memo into project notes |
### Transcribe YouTube Video Automation Settings
{% hint style="info" %}
The Transcribe YouTube Video action converts video audio into searchable, readable text using advanced AI transcription. Perfect for content indexing, accessibility, educational resources, and content repurposing.
{% endhint %}
#### When to Use Transcribe YouTube Video
**Perfect for:**
* **Content indexing** - Make video content searchable and referenceable
* **Educational resources** - Create study guides and learning materials
* **Content repurposing** - Transform video content into blogs, articles, and social posts
* **Accessibility** - Provide text transcripts for hearing-impaired users
* **Research and analysis** - Extract insights from video presentations
* **Knowledge management** - Build searchable video content libraries
#### Transcribe YouTube Video Parameters
| Parameter | Description | Example |
| -------------------------- | ----------------------------------------- | --------------------------------------------- |
| **URL** | YouTube video URL to transcribe | `https://www.youtube.com/watch?v=VIDEO_ID` |
| **Language** | Audio language for accurate transcription | `en` (English), `es` (Spanish), `fr` (French) |
| **Include Timestamps** | Add time markers to transcript | `true`/`false` |
| **Output Format** | Transcript format (text, JSON, SRT) | `text`, `json`, `srt` |
| **Speaker Identification** | Identify different speakers | `true`/`false` |
#### Transcribe YouTube Video Use Cases
| Use Case | Automation Flow | Business Impact |
| ------------------------- | ---------------------------------------------- | --------------------------------------- |
| **Content Indexing** | Schedule β Transcribe β Index in Search | Searchable transcripts of your videos |
| **Educational Resources** | Task Added β Transcribe β Generate Study Guide | Accelerated learning materials creation |
| **Content Repurposing** | Video Upload β Transcribe β Generate Blog Post | Multi-platform content distribution |
| **Accessibility** | Video Published β Transcribe β Add Captions | Improved content accessibility |
| **Research Analysis** | Video Found β Transcribe β Extract Insights | Faster research and analysis |
#### Integration Examples
**Educational Content Pipeline:**
```
Trigger: Video Added to Course
Action: Transcribe YouTube Video (with timestamps)
Action: Generate Study Guide with AI
Action: Create Quiz Questions
Action: Add to Learning Management System
Result: Automated course content creation
```
**Content Repurposing Workflow:**
```
Trigger: YouTube Video Published
Action: Transcribe YouTube Video
Action: Ask Agent With Structured Output (Extract key points)
Action: Generate Blog Post with AI
Action: Publish to Website
Result: Multi-platform content distribution
```
**Research and Analysis System:**
```
Trigger: Weekly Schedule
Action: Search Web (Industry videos)
Action: Transcribe YouTube Video (Top results)
Action: Categorize with AI (Topics)
Action: Generate Research Summary
Action: Add to Knowledge Base
Result: Automated industry research
```
#### Output Data Structure
**Basic Text Output:**
```
[00:00:15] Welcome to our product demonstration video.
[00:00:22] Today we'll show you the key features...
[00:00:45] Let's start with the user interface...
```
**JSON Output:**
```json
{
"video_url": "https://www.youtube.com/watch?v=VIDEO_ID",
"title": "Product Demo",
"duration": "00:15:30",
"language": "en",
"transcript": [
{
"timestamp": "00:00:15",
"text": "Welcome to our product demonstration video.",
"speaker": "presenter"
},
{
"timestamp": "00:00:22",
"text": "Today we'll show you the key features...",
"speaker": "presenter"
}
],
"confidence_score": 0.92
}
```
#### Advanced Features
**Multi-Language Support:**
* **Automatic Language Detection** - Identifies audio language automatically
* **Manual Language Selection** - Specify language for better accuracy
* **Multi-Language Videos** - Handle videos with multiple languages
**Speaker Identification:**
* **Speaker Diarization** - Distinguish between different speakers
* **Speaker Labels** - Assign names or roles to speakers
* **Conversation Analysis** - Identify Q\&A sections and discussions
**Timestamp Integration:**
* **Precise Timestamps** - Accurate time markers for each phrase
* **Chapter Markers** - Identify natural breaks and sections
* **Interactive Transcripts** - Click timestamps to jump to video sections
#### Best Practices
* **Video Quality Matters** - Clear audio produces better transcripts
* **Supported Languages** - Check language support for your content
* **Privacy Considerations** - Review content before public sharing
* **Cost Management** - Long videos may incur higher processing costs
* **Quality Validation** - Review important transcripts for accuracy
* **Integration Planning** - Consider downstream processing of transcript data
#### Rate Limiting & Performance
* **Processing Time** - Longer videos take more time to process
* **API Limits** - May have daily/hourly processing limits
* **Cost Per Minute** - Pricing based on video duration
* **Batch Processing** - Process multiple videos efficiently
* **Caching** - Store transcripts to avoid re-processing
#### Content Repurposing Workflows
**Blog Post Generation:**
```
YouTube Video β Transcribe β Extract Key Points β Generate Blog Post β SEO Optimize β Publish
```
**Social Media Content:**
```
YouTube Video β Transcribe β Identify Highlights β Create Short Clips β Generate Captions β Post to Social
```
**Educational Materials:**
```
YouTube Video β Transcribe β Generate Quiz β Create Study Guide β Add to LMS β Track Completion
```
***
| Action | Description | Parameters | Example |
| -------------------------------- | -------------------------------------------- | ------------------------------------ | ----------------------------------------- |
| **Generate Image with DALLΒ·E 3** | Create images from text prompts using OpenAI | `prompt`, `size`, `style`, `quality` | Generate illustrations and visual content |
### HTTP Request Automation Settings
{% hint style="info" %}
HTTP (HyperText Transfer Protocol) is the foundation of web communication. The HTTP Request action allows you to connect Taskade with any web service or API, enabling seamless data exchange and integration.
{% endhint %}
#### HTTP Request Parameters
| Parameter | Description | Example |
| ---------------------- | ------------------------------------------------ | ----------------------------------------------- |
| **Method** | HTTP method (GET, POST, PUT, DELETE, etc.) | `POST` |
| **URL** | The endpoint URL to send the request to | `https://api.example.com/v1/users` |
| **Headers** | HTTP headers (Authorization, Content-Type, etc.) | `Authorization: Bearer token123` |
| **Query Params** | URL query parameters | `?limit=10&sort=date` |
| **Body Type** | Request body format (JSON, Form Data, Raw, XML) | `JSON` |
| **Body Content** | The actual data to send | `{"name": "John", "email": "john@example.com"}` |
| **Response Body Type** | How to process the response (JSON or None) | `JSON` |
#### HTTP Request Use Cases
| Use Case | Automation Flow | Example |
| ----------------------- | --------------------------------------------- | ----------------------------------------- |
| **Weather Data** | Schedule β HTTP Request β Add Task | Get daily weather for project planning |
| **Email Validation** | Task Added β HTTP Request β Update Fields | Validate contact emails automatically |
| **Content Translation** | Task Added β HTTP Request β Append Text | Translate content for international teams |
| **Stock Prices** | Schedule β HTTP Request β Insert Row | Track investment portfolio data |
| **Public Holidays** | Project Created β HTTP Request β Create Event | Add holidays to project calendars |
| **Business Lookup** | Form Submitted β HTTP Request β Update Fields | Enrich contact data with company info |
### DALLΒ·E 3 Image Generation Settings
{% hint style="info" %}
The Generate Image with DALLΒ·E 3 action creates beautiful images from text prompts using OpenAI's advanced image generation technology. Perfect for illustrations, concept art, and visual content creation.
{% endhint %}
#### Setup Requirements
**OpenAI API Key Required:**
1. Visit [OpenAI Platform](https://platform.openai.com/api-keys)
2. Create a new API key with DALLΒ·E access
3. Add the key to your Taskade automation settings
#### DALLΒ·E 3 Parameters
| Parameter | Description | Options | Default |
| ----------- | ----------------------------------------- | ------------------------------------- | ----------- |
| **Prompt** | Text description of the image to generate | Any descriptive text | Required |
| **Size** | Image dimensions | `1024x1024`, `1024x1792`, `1792x1024` | `1024x1024` |
| **Style** | Visual style preference | `vivid`, `natural` | `vivid` |
| **Quality** | Image quality level | `standard`, `hd` | `standard` |
#### DALLΒ·E 3 Use Cases
| Use Case | Automation Flow | Example |
| ----------------------------- | ------------------------------------------------ | ----------------------------------- |
| **Visual Content Generation** | Task Added β Generate Image β Add to Project | Create illustrations for blog posts |
| **Creative Project Support** | Task Created β Generate Image β Attach to Task | Add moodboards and concept images |
| **Social Media Visuals** | Schedule β Generate Image β Post to Social | Create dynamic social media content |
| **Learning Materials** | Task Added β Generate Image β Embed in Content | Make educational materials engaging |
| **Product Prototyping** | Task Created β Generate Image β Review & Iterate | Produce concept images for products |
**Prompt Engineering Tips:**
* Be specific about style, lighting, and composition
* Include artistic references (e.g., "in the style of Picasso")
* Specify image format and intended use
* Use descriptive adjectives for better results
### Taskade Genesis β Image Format Conversion
{% hint style="info" %}
The **Image Format Conversion** action (available in Genesis flows) converts an image from one format to another entirely within Taskade β no external service required. Useful for normalizing images before uploading them to downstream steps.
{% endhint %}
| Action | Description | Parameters | Example |
| --------------------------- | ------------------------------------------------------------------------ | ------------------------------------- | ---------------------------------------------- |
| **Image Format Conversion** | Converts an image file to a target format (e.g., PNG β JPEG, WebP, etc.) | `imageUrl`, `targetFormat`, `quality` | Convert an uploaded PNG to WebP before storing |
Supported target formats include common raster types (JPEG, PNG, WebP, and more). Output is returned as a file reference that can be passed to subsequent actions such as **Upload File to Media**.
### Categorize with AI Automation Settings
{% hint style="info" %}
The Categorize with AI action automatically analyzes, classifies, and organizes information using advanced AI algorithms. Choose from dozens of preset categories or create custom classification schemes for your specific needs.
{% endhint %}
#### When to Use Categorize with AI
**Perfect for:**
* **Sentiment analysis** - Determine positive, neutral, or negative sentiment in feedback
* **Lead qualification** - Score and prioritize potential customers
* **Content moderation** - Filter inappropriate or sensitive content
* **Support prioritization** - Route tickets based on urgency and type
* **Data organization** - Automatically tag and sort incoming information
#### Preset Categories Available
| Category Type | Use Cases | Output Format |
| -------------------------- | ---------------------------------------- | -------------------------------------------- |
| **Sentiment Analysis** | Customer feedback, reviews, social media | Positive/Neutral/Negative + confidence score |
| **Lead Qualification** | Sales inquiries, prospect data | Hot/Warm/Cold + priority score |
| **Content Moderation** | User-generated content, comments | Safe/Questionable/Inappropriate |
| **Support Prioritization** | Help tickets, customer issues | Critical/High/Medium/Low |
| **Language Detection** | Multi-language content | Language code + confidence |
| **Topic Classification** | Articles, documents | Primary topic + subtopics |
#### Custom Category Configuration
**Example: Customer Support Ticket Classification**
```json
{
"custom_categories": {
"billing": ["payment", "invoice", "charge", "refund"],
"technical": ["error", "bug", "login", "performance"],
"account": ["password", "profile", "settings", "access"],
"feature": ["request", "suggestion", "improvement", "new"]
},
"output_format": "single_best_match",
"confidence_threshold": 0.7
}
```
#### Categorize with AI Use Cases
| Use Case | Automation Flow | Business Impact |
| ---------------------- | ----------------------------------------------- | --------------------------------- |
| **Sentiment Analysis** | Form Submission β Categorize β Route Response | Faster, routed customer responses |
| **Lead Qualification** | New Contact β Categorize β Assign Sales Rep | Leads routed to the right rep |
| **Support Routing** | Ticket Created β Categorize β Assign Agent | Tickets categorized and assigned |
| **Content Moderation** | User Post β Categorize β Approve/Reject | Maintains community standards |
| **Feedback Analysis** | Survey Response β Categorize β Update Dashboard | Data-driven product improvements |
#### Integration Examples
**Customer Support Automation:**
```
Trigger: Support Ticket Created
Action: Categorize with AI (Support Prioritization)
Branch: If "Critical" β Escalate + SMS Alert
If "High" β Assign Senior Agent + Email
If "Medium" β Add to Queue + Auto-Response
If "Low" β Self-Service Resources
```
**Lead Management System:**
```
Trigger: Lead Form Submission
Action: Categorize with AI (Lead Qualification)
Action: Update Custom Field (Lead Score)
Branch: If Score > 8 β Immediate Sales Call
If Score > 5 β Email Sequence
If Score β€ 5 β Nurture Campaign
```
**Content Moderation Workflow:**
```
Trigger: User Comment Posted
Action: Categorize with AI (Content Moderation)
Branch: If "Safe" β Publish Immediately
If "Questionable" β Human Review Queue
If "Inappropriate" β Block + Notify Moderator
```
#### Configuration Best Practices
* **Start with presets** before creating custom categories
* **Set confidence thresholds** to balance accuracy vs. coverage
* **Test with sample data** to validate categorization accuracy
* **Monitor and refine** categories based on real-world performance
* **Combine with human review** for critical decisions
#### Output Data Structure
**Standard Response Format:**
```json
{
"category": "sentiment_positive",
"confidence": 0.89,
"subcategories": ["satisfied", "recommend"],
"metadata": {
"processing_time": 0.3,
"model_version": "v2.1",
"input_length": 247
}
}
```
**Batch Processing Response:**
```json
{
"results": [
{
"item_id": "feedback_123",
"category": "technical_issue",
"confidence": 0.92
},
{
"item_id": "feedback_124",
"category": "feature_request",
"confidence": 0.78
}
],
"summary": {
"total_processed": 50,
"average_confidence": 0.84,
"categories_found": 8
}
}
```
***
### Search Web Automation Settings
{% hint style="info" %}
The Search Web action enables automations to gather real-time information from the internet. Perfect for research, content creation, market analysis, and keeping your workflows updated with the latest information.
{% endhint %}
#### When to Use Search Web
**Perfect for:**
* **Research automation** - Gather up-to-date information for reports and presentations
* **Content creation** - Find relevant data and trends for blog posts and articles
* **Market analysis** - Monitor competitor activity and industry trends
* **Background checking** - Verify information and gather additional context
* **Data enrichment** - Enhance existing data with web-sourced information
#### Search Web Use Cases
| Use Case | Automation Flow | Business Impact |
| ------------------------- | ----------------------------------------- | -------------------------- |
| **Resume Verification** | Task Added β Search Web β Compare Results | Improved hiring quality |
| **Content Research** | Schedule β Search Web β Generate Article | Faster content creation |
| **Market Intelligence** | Schedule β Search Web β Update Dashboard | Better strategic decisions |
| **Competitor Analysis** | Task Added β Search Web β Analyze Trends | Competitive advantage |
| **Automated Newsletters** | Schedule β Search Web β Curate Content | Engaging communications |
#### Configuration Options
| Setting | Description | Example |
| --------------- | ---------------------------------- | ------------------------ |
| **Query** | Search terms to use for web search | "latest AI trends 2024" |
| **Max Results** | Number of results to return | 5, 10, 20 |
| **Safe Search** | Filter inappropriate content | Enabled for business use |
| **Date Range** | Limit to recent results | Past 24 hours, past week |
| **Language** | Search in specific language | English, Spanish, etc. |
#### Integration Examples
**Research Automation Workflow:**
```
Trigger: Task Added (Research Topic)
Action: Search Web (Query from task name)
Action: Ask Agent With Structured Output (Summarize findings)
Action: Create Project (Research Report)
Result: Automated research compilation
```
**Content Creation Pipeline:**
```
Trigger: Schedule (Daily)
Action: Search Web (Industry news)
Action: Categorize with AI (Topic classification)
Action: Generate with AI (News summary)
Action: Publish to Blog
Result: Automated content publishing
```
**Competitor Monitoring:**
```
Trigger: Schedule (Weekly)
Action: Search Web (Competitor name + news)
Action: Analyze with AI (Impact assessment)
Action: Update Custom Fields (Competitor activity)
Action: Send Slack Alert (If significant changes)
Result: Proactive competitive intelligence
```
#### Output Data Structure
**Search Results Format:**
```json
{
"query": "AI trends 2024",
"results": [
{
"title": "Top AI Trends for 2024",
"url": "https://example.com/ai-trends",
"snippet": "Key AI developments expected in 2024...",
"source": "TechCrunch",
"date": "2024-01-15"
}
],
"total_results": 1250000,
"search_time": 0.45
}
```
#### Best Practices
* **Craft specific queries** for better, more relevant results
* **Use date filters** to focus on recent information
* **Combine with AI analysis** to process and summarize findings
* **Set reasonable limits** to avoid overwhelming downstream actions
* **Monitor search costs** for high-volume automations
#### Rate Limiting & Performance
* **API quotas** may apply depending on search provider
* **Response times** vary based on query complexity
* **Caching** can be implemented for repeated searches
* **Error handling** important for network-dependent actions
***
## Communication Actions
### Slack
| Action | Description | Parameters | Example |
| ----------------------- | ------------------------ | ------------------------------------ | ------------------------------- |
| `slack.sendMessage` | Sends message to channel | `channel`, `message`, `attachments` | Notify team of new ticket |
| `slack.sendDM` | Sends direct message | `userId`, `message` | Alert assignee of urgent task |
| `slack.createChannel` | Creates new channel | `name`, `description`, `isPrivate` | Create project-specific channel |
| `slack.inviteUser` | Invites user to channel | `channelId`, `userId` | Add stakeholder to discussion |
| `slack.updateStatus` | Updates user status | `userId`, `status`, `emoji` | Set "In meeting" status |
| `slack.scheduleMessage` | Schedules message | `channel`, `message`, `scheduleTime` | Send reminder tomorrow |
### Email
| Action | Description | Parameters | Example |
| ---------------------- | ---------------------------- | -------------------------------------- | --------------------------------- |
| `email.send` | Sends email | `to`, `subject`, `body`, `attachments` | Send confirmation to customer |
| `email.sendTemplate` | Sends templated email | `to`, `templateId`, `variables` | Send welcome email with variables |
| `email.addToList` | Adds contact to mailing list | `email`, `listId`, `customFields` | Subscribe to newsletter |
| `email.removeFromList` | Removes from mailing list | `email`, `listId` | Unsubscribe user |
| `email.createCampaign` | Creates email campaign | `listId`, `subject`, `content` | Launch product announcement |
### Discord
| Action | Description | Parameters | Example |
| ---------------------- | ------------------------ | --------------------------------- | ------------------------------- |
| `discord.sendMessage` | Sends message to channel | `channelId`, `message`, `embed` | Post update to community |
| `discord.createRole` | Creates new role | `guildId`, `name`, `permissions` | Create "Beta Tester" role |
| `discord.assignRole` | Assigns role to user | `guildId`, `userId`, `roleId` | Grant access to private channel |
| `discord.createInvite` | Creates invite link | `channelId`, `maxUses`, `expires` | Generate one-time invite |
### Notify by Email (Native)
{% hint style="success" %}
Taskade includes a built-in **Notify by Email** action that sends transactional notifications through Taskade's own mail infrastructure. No OAuth connection or third-party email provider is required.
{% endhint %}
| Action | Description | Parameters | Example |
| ------------------- | ---------------------------------------------------------- | ----------------------- | ------------------------------------------ |
| **Notify by Email** | Sends a notification email via Taskade (no OAuth required) | `to`, `subject`, `body` | Alert a stakeholder when a task is created |
This action is distinct from the `email.send` integration rows above, which require an external mail provider connection.
## Data & CRM Actions
### HubSpot
| Action | Description | Parameters | Example |
| ----------------------- | -------------------------- | ---------------------------------------------- | ------------------------ |
| `hubspot.createContact` | Creates new contact | `email`, `firstName`, `lastName`, `properties` | Add lead from form |
| `hubspot.updateContact` | Updates contact properties | `contactId`, `properties` | Update lead score |
| `hubspot.createDeal` | Creates new deal | `contactId`, `dealName`, `amount`, `stage` | Create sales opportunity |
| `hubspot.updateDeal` | Updates deal properties | `dealId`, `properties` | Move to next stage |
| `hubspot.createTask` | Creates task for contact | `contactId`, `title`, `dueDate` | Schedule follow-up call |
| `hubspot.addNote` | Adds note to contact | `contactId`, `note` | Log interaction details |
### Salesforce
| Action | Description | Parameters | Example |
| --------------------------- | ---------------------------- | ------------------------------------------- | ---------------------------- |
| `salesforce.createLead` | Creates new lead | `email`, `firstName`, `lastName`, `company` | Add qualified lead |
| `salesforce.convertLead` | Converts lead to opportunity | `leadId`, `accountName` | Convert to sales opportunity |
| `salesforce.createCase` | Creates support case | `contactId`, `subject`, `description` | Log support ticket |
| `salesforce.updateCase` | Updates case status | `caseId`, `status`, `priority` | Escalate to manager |
| `salesforce.createActivity` | Creates activity record | `recordId`, `type`, `subject` | Log call or meeting |
### Google Sheets
| Action | Description | Parameters | Example |
| -------------------- | --------------------- | ---------------------------------------- | ------------------------ |
| `sheets.addRow` | Adds new row to sheet | `spreadsheetId`, `range`, `values` | Log form submission |
| `sheets.updateCell` | Updates specific cell | `spreadsheetId`, `cell`, `value` | Update status column |
| `sheets.findRow` | Finds row by criteria | `spreadsheetId`, `column`, `searchValue` | Find customer record |
| `sheets.deleteRow` | Deletes row | `spreadsheetId`, `rowIndex` | Remove processed entry |
| `sheets.createChart` | Creates chart | `spreadsheetId`, `range`, `chartType` | Generate analytics chart |
### Airtable
| Action | Description | Parameters | Example |
| ----------------------- | ---------------------- | -------------------------------------------------- | -------------------------- |
| `airtable.createRecord` | Creates new record | `baseId`, `tableId`, `fields` | Add customer to CRM |
| `airtable.updateRecord` | Updates record fields | `baseId`, `tableId`, `recordId`, `fields` | Update project status |
| `airtable.linkRecords` | Links records together | `baseId`, `tableId`, `recordId`, `linkedRecordIds` | Connect customer to orders |
| `airtable.deleteRecord` | Deletes record | `baseId`, `tableId`, `recordId` | Remove obsolete entry |
## Development Actions
### GitHub
| Action | Description | Parameters | Example |
| ---------------------- | --------------------- | ----------------------------------------------- | ------------------------ |
| `github.createIssue` | Creates new issue | `repo`, `title`, `body`, `labels` | Report bug from feedback |
| `github.updateIssue` | Updates issue | `repo`, `issueNumber`, `title`, `body`, `state` | Close resolved issue |
| `github.addComment` | Adds comment to issue | `repo`, `issueNumber`, `comment` | Add investigation notes |
| `github.createPR` | Creates pull request | `repo`, `title`, `body`, `head`, `base` | Submit fix for review |
| `github.mergePR` | Merges pull request | `repo`, `prNumber`, `mergeMethod` | Auto-merge approved PR |
| `github.createRelease` | Creates release | `repo`, `tag`, `name`, `body` | Publish new version |
### Jira
| Action | Description | Parameters | Example |
| ---------------------- | --------------------- | ------------------------------------------------ | --------------------------- |
| `jira.createIssue` | Creates new issue | `project`, `issueType`, `summary`, `description` | Create bug ticket |
| `jira.updateIssue` | Updates issue fields | `issueKey`, `fields` | Update priority or assignee |
| `jira.transitionIssue` | Changes issue status | `issueKey`, `transitionId` | Move to "In Progress" |
| `jira.addComment` | Adds comment | `issueKey`, `comment` | Add troubleshooting notes |
| `jira.assignIssue` | Assigns issue to user | `issueKey`, `assignee` | Assign to developer |
## Web & Content Actions
### WordPress
| Action | Description | Parameters | Example |
| --------------------------- | --------------------- | ------------------------------------------ | ---------------------- |
| `wordpress.createPost` | Creates new post | `title`, `content`, `status`, `categories` | Publish blog article |
| `wordpress.updatePost` | Updates existing post | `postId`, `title`, `content`, `status` | Edit published content |
| `wordpress.createPage` | Creates new page | `title`, `content`, `parent` | Add landing page |
| `wordpress.uploadMedia` | Uploads media file | `file`, `title`, `description` | Add featured image |
| `wordpress.moderateComment` | Moderates comment | `commentId`, `status` | Approve or reject |
### Webflow
| Action | Description | Parameters | Example |
| --------------------- | ---------------------- | ---------------------------------- | -------------------- |
| `webflow.createItem` | Creates CMS item | `collectionId`, `fields` | Add new blog post |
| `webflow.updateItem` | Updates CMS item | `collectionId`, `itemId`, `fields` | Edit product details |
| `webflow.publishSite` | Publishes site changes | `siteId` | Deploy updates live |
| `webflow.createForm` | Creates form | `name`, `fields` | Add contact form |
## Utility Actions
### HTTP/Webhook
| Action | Description | Parameters | Example |
| -------------- | --------------------- | --------------------------- | ----------------------- |
| `http.post` | Sends POST request | `url`, `headers`, `body` | Call external API |
| `http.get` | Sends GET request | `url`, `headers`, `params` | Fetch data from service |
| `http.put` | Sends PUT request | `url`, `headers`, `body` | Update external record |
| `http.delete` | Sends DELETE request | `url`, `headers` | Remove external data |
| `webhook.send` | Sends webhook payload | `url`, `payload`, `headers` | Notify external system |
### Data Processing
| Action | Description | Parameters | Example |
| ---------------- | --------------------------------------------------------------- | ---------------------------------- | ------------------------------------ |
| `data.transform` | Transforms data format | `input`, `mapping`, `outputFormat` | Convert CSV to JSON |
| `data.validate` | Validates data schema | `input`, `schema` | Check required fields |
| `data.merge` | Merges data objects | `objects`, `mergeStrategy` | Combine multiple sources |
| `data.filter` | Filters data by criteria | `input`, `conditions` | Remove invalid entries |
| `data.aggregate` | Aggregates data | `input`, `groupBy`, `functions` | Calculate totals |
| **split** | Splits a text string into an array on a delimiter | `text`, `delimiter` | Split CSV line into fields |
| **trim** | Removes leading and trailing whitespace from a text string | `text` | Clean user-submitted input |
| **convertCase** | Converts text case (uppercase, lowercase, titleCase, camelCase) | `text`, `targetCase` | Normalize status labels to lowercase |
### Utilities
Pure, no-credit transform actions for reshaping data inline in a flow β no AI call required.
| Action | Description | Parameters | Example |
| ------------------------ | --------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- | ---------------------------------- |
| `utils.generateQrCode` | Renders text or a URL into a QR image saved to your workspace Media library | `text` (required), `size` (150/300/600 px), `errorCorrection` (L/M/Q/H) | Encode a check-in URL as a QR code |
| `utils.convertCsvToJson` | Parses a CSV string into structured rows | `csv` (required), `hasHeader` (header/noHeader), `delimiter` (optional, auto-detect) | Turn an upload into JSON rows |
| `utils.convertJsonToCsv` | Serializes a JSON array into CSV | `json` (required), `includeHeader` (yes/no), `delimiter` (optional, default `,`) | Export records to a spreadsheet |
| `utils.calculateAverage` | Mean of a list of numbers | `values` (required) | Average response time |
| `utils.calculateSum` | Total of a list of numbers | `values` (required) | Sum order amounts |
| `utils.countUniques` | Counts the distinct values in a list | `values` (required) | Count unique customers |
| `utils.getMinMax` | Highest or lowest value in a list | `values` (required), `mode` (max/min) | Find the largest invoice |
| `utils.concat` | Joins multiple parts into one string | `parts` (required), `separator` (optional) | Build a full name from fields |
| `utils.find` | Locates a search value in a string (first match or all) | `text` (required), `searchValue` (required), `mode` (first/all), `caseSensitivity` (optional) | Find a keyword in a message |
| `utils.slugify` | Turns text into a URL-safe slug | `text` (required), `casing` (optional), `separator` (default `-`) | Slugify an article title |
| `utils.stripHtml` | Removes markup and returns plain text | `html` (required) | Clean HTML email body |
| `utils.htmlToMarkdown` | Converts an HTML fragment to Markdown | `html` (required) | Store content as Markdown |
| `utils.markdownToHtml` | Renders Markdown to sanitized HTML | `markdown` (required) | Publish formatted content |
### File Operations
| Action | Description | Parameters | Example |
| --------------- | ----------------------- | --------------------------------- | ---------------------- |
| `file.upload` | Uploads file to storage | `file`, `destination`, `metadata` | Store form attachment |
| `file.download` | Downloads file | `url`, `destination` | Save external resource |
| `file.convert` | Converts file format | `file`, `targetFormat` | PDF to images |
| `file.compress` | Compresses file | `file`, `compressionLevel` | Reduce file size |
## Conditional Actions
### Logic & Control Flow
| Action | Description | Parameters | Example |
| ------------------ | ------------------------- | --------------------------- | ----------------------------------- |
| `condition.if` | Conditional execution | `condition`, `then`, `else` | If priority is high, notify manager |
| `condition.switch` | Multi-way branching | `value`, `cases`, `default` | Route by category |
| `loop.forEach` | Iterate over array | `array`, `actions` | Process each item |
| `loop.while` | Loop while condition true | `condition`, `actions` | Retry until success |
| `delay.wait` | Wait for specified time | `duration` | Wait 5 minutes before retry |
## Error Handling
| Action | Description | Parameters | Example |
| -------------- | -------------------------- | -------------------------------- | ---------------------- |
| `error.catch` | Catches and handles errors | `actions`, `errorHandler` | Retry on failure |
| `error.retry` | Retries failed actions | `actions`, `maxRetries`, `delay` | Retry API call 3 times |
| `error.notify` | Sends error notification | `message`, `recipients` | Alert admin of failure |
| `error.log` | Logs error details | `error`, `context` | Record for debugging |
## Usage Examples
### Basic Action Chain
```json
{
"actions": [
{
"type": "taskade.createTask",
"projectId": "proj_123",
"title": "{{form.subject}}",
"content": "{{form.description}}"
},
{
"type": "slack.sendMessage",
"channel": "#support",
"message": "New task created: {{previous.title}}"
}
]
}
```
### Conditional Logic
```json
{
"actions": [
{
"type": "condition.if",
"condition": "{{form.priority}} === 'high'",
"then": [
{
"type": "slack.sendMessage",
"channel": "#urgent",
"message": "High priority: {{form.subject}}"
}
],
"else": [
{
"type": "taskade.createTask",
"projectId": "backlog",
"title": "{{form.subject}}"
}
]
}
]
}
```
### Error Handling
```json
{
"actions": [
{
"type": "error.retry",
"maxRetries": 3,
"delay": 1000,
"actions": [
{
"type": "http.post",
"url": "https://api.example.com/webhook",
"body": "{{trigger.data}}"
}
]
}
]
}
```
***
## **Advanced File Handling**
Recent updates have significantly enhanced automation file processing capabilities.
### **Multipart File Uploads**
HTTP actions now support multipart file uploads, enabling seamless integration with modern APIs:
```json
{
"action": "Send HTTP Request",
"method": "POST",
"url": "https://api.example.com/upload",
"headers": {
"Authorization": "Bearer {{token}}"
},
"files": {
"document": "{{file_from_trigger}}",
"thumbnail": "{{generated_image}}"
},
"body": {
"title": "{{document_title}}",
"category": "{{document_type}}"
}
}
```
### **Enhanced Webhook File Processing**
Webhooks can now receive and process multipart/form-data, perfect for:
* **Document Processing Workflows**: Automatically process uploaded files
* **Image Analysis Pipelines**: Analyze images submitted through forms
* **File Validation Systems**: Check file types and sizes before processing
### **Smart Form Field Mapping**
When forms trigger automations that create tasks, the system intelligently maps form field labels to task custom fields:
* **Automatic Matching**: "Priority Level" dropdown β Priority custom field
* **Type Recognition**: Date fields map to date custom fields automatically
* **Dynamic Options**: Dropdown values sync with custom field options
### **Professional Use Cases**
**Document Approval Workflow:**
```
Form Upload β File Validation β Manager Notification β Approval Task Creation
```
**Image Processing Pipeline:**
```
Image Upload β AI Analysis β Metadata Extraction β Database Storage
```
**Client Onboarding System:**
```
Document Collection β Verification β CRM Update β Welcome Email
```
### **File Type Support**
Automations now handle a wide range of file types:
* **Documents**: PDF, DOC, DOCX, TXT, RTF
* **Images**: JPG, PNG, GIF, WebP, SVG
* **Spreadsheets**: CSV, XLS, XLSX
* **Archives**: ZIP, RAR, 7Z
* **Media**: MP4, MP3, WAV, MOV
***
β **Next:** [**Advanced Automation Actions**](/automations/automation/advanced-actions)\
β **See Also:** [**Automation Recipes**](/automations/automation/recipes)
# Workflow Generator
Build complex automations in Taskade from plain English: the Workflow Generator creates triggers, branches, loops, and 100+ integrations with no drag-and-drop.
***
## Table of Contents
* [Overview](#overview)
* [What You Can Build](#what-you-can-build)
* [How to Get Started](#how-to-get-started)
* [Generator Modes](#generator-modes)
* [Smart Edits & Chat Commands](#smart-edits-and-chat-commands)
* [Key Features](#key-features)
* [Workflow Building Blocks](#workflow-building-blocks)
* [Example Prompts](#example-prompts)
* [What's Next](#whats-next)
***
## Overview
The Workflow Generator builds complex automation flows from **natural language**. Describe what you want in plain English, and the AI creates complete workflows with triggers, conditions, branches, loops, and integrations across 100+ services β no drag-and-drop, no manual configuration.
> **Taskade Genesis connection:** Genesis apps automatically generate workflow automations as part of the Execution pillar. The Workflow Generator lets you create additional automations or modify existing ones. Each automation adds **+5 points** to your [Intelligence Score](https://www.taskade.com/learn/genesis).
***
## What You Can Build
| Category | Example Prompt | What's Created |
| ------------------------ | ------------------------------------------------------------------------------------- | ------------------------------------------------------------------- |
| **Multi-step workflows** | "When a form is submitted, create a task, notify the team, and send follow-up emails" | Form trigger β Task creation β Slack notification β Gmail follow-up |
| **Content pipelines** | "Monitor X for new content, summarize it, and create a new project for each item" | RSS trigger β AI summary β Project creation loop |
| **Scheduled reports** | "Every Monday, generate a progress report and share with stakeholders" | Weekly schedule β AI report generation β Email distribution |
| **Agent-powered flows** | "Create an AI Agent that processes customer feedback and assigns follow-up" | Agent trigger β Sentiment analysis β Task assignment |
| **Social distribution** | "Build an automation that posts our blog content to social media" | RSS/webhook trigger β AI rewrite β Multi-platform posting |
***
## How to Get Started
### Step-by-Step Tutorial
| Step | Action |
| ---- | -------------------------------------------------------------------------------------- |
| 1 | Navigate to **Automations** tab β **Create Flow** (or visit `taskade.com/create/flow`) |
| 2 | Describe your desired workflow in the chat |
| 3 | Watch the Workflow Generator build, refine, and optimize it |
| 4 | Review the generated flow |
| 5 | Click **Create Automation** to save it |
| 6 | Customize triggers, actions, and conditions as needed |
| 7 | Toggle the automation **On** |
***
## Generator Modes
| Mode | Description | Best For |
| ------------------- | -------------------------------------------------------- | ------------------------------ |
| **Auto** (default) | AI selects the optimal mode for your task | Most use cases β let AI decide |
| **Agent Tool Mode** | Generates intelligent workflows as an AI agent tool | Agent-powered decision-making |
| **Workflow Mode** | Sets up standard project automations and flows | Task management, notifications |
| **Form Mode** | Generates smart forms that trigger actions on submission | Lead capture, surveys, intake |
***
## Smart Edits & Chat Commands
After generating a workflow, modify it with natural language:
| Edit Type | Example Prompt | What Happens |
| ------------------- | ----------------------------------------------------- | --------------------------- |
| **Add step** | "Add a Slack notification to this workflow" | New Slack action added |
| **Add logic** | "Add branching logic based on the form response" | Conditional branch inserted |
| **Change trigger** | "Change the trigger to run daily instead of weekly" | Schedule trigger updated |
| **Add loop** | "Loop through all tasks and send a reminder for each" | Loop action added |
| **Modify action** | "Change the email to send to managers instead" | Action recipient updated |
| **Add integration** | "Also post a summary to our Slack channel" | New integration step added |
| **Optimize** | "Make this workflow more efficient" | AI suggests improvements |
***
## Key Features
| Feature | What It Means |
| ------------------------- | ------------------------------------------------------- |
| **Instant Creation** | Build complex flows in minutes, not hours |
| **Natural Language** | Describe any complexity β AI handles the implementation |
| **Intelligent Editing** | Modify existing workflows with plain-English requests |
| **Smart Recommendations** | AI-driven optimization tips and improvements |
| **Built-in Integrations** | Connect with 100+ apps β AI guides setup |
| **Branching** | Conditional paths based on data values |
| **Looping** | Iterate over lists of items |
| **Variables** | Dynamic data passing between steps (Liquid expressions) |
| **AI Steps** | Agent-powered reasoning within workflows |
***
## Workflow Building Blocks
| Block | Description | Example |
| ------------ | --------------------------- | --------------------------------------------------- |
| **Trigger** | What starts the flow | Form submitted, schedule, webhook, new email |
| **Action** | What happens | Send email, create task, post to Slack |
| **Branch** | Conditional logic (if/else) | If rating < 3, alert manager; else, log to database |
| **Loop** | Iterate over a list | For each attachment, upload to Media |
| **Delay** | Pause execution | Wait 24 hours, then send follow-up |
| **AI Step** | Agent-powered processing | Agent categorizes ticket, generates response |
| **Variable** | Dynamic data | `{{trigger.email}}`, `{{step1.output}}` |
***
## Example Prompts
| Prompt | Flow Generated |
| ---------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| "When a customer submits feedback with a rating below 3, alert the support manager on Slack and create a high-priority task" | Form Trigger β Branch (rating < 3) β Slack Message β Create Task (priority: high) |
| "Every day at 9 AM, summarize all overdue tasks and email them to team leads" | Daily Schedule β Find overdue tasks β AI summarize β Send Email |
| "When a new lead fills the contact form, add them to HubSpot, send a welcome email, and notify sales on Slack" | Form Trigger β Create HubSpot Contact β Send Gmail β Slack Message |
| "Monitor our blog RSS feed, summarize new posts with AI, and share on Twitter and LinkedIn" | RSS Trigger β AI Summary β Create Post (Twitter) β Create Update (LinkedIn) |
| "When a task is completed, update the Google Sheet tracker and notify the project channel" | Task Completed β Insert Row (Google Sheets) β Send Slack Message |
***
## What's Next
| Guide | What You'll Learn |
| ------------------------------------------------------- | ----------------------------------------- |
| [Automation Triggers](/automations/automation) | All available triggers for your workflows |
| [Taskade Autopilot](/ai-features/ai-features/autopilot) | Generate entire workspace ecosystems |
# Integration Overview
Connect Taskade to Slack, Gmail, HubSpot, Sheets and more with trigger-and-action automations, plus custom HTTP, webhook, and API integrations.
**Transform isolated tools into intelligent, living ecosystems that learn, adapt, and evolve together.**
{% hint style="success" %}
**Living Integrations** go beyond static connectionsβthey create intelligent relationships between systems that learn from data flow patterns, adapt to changing business needs, and continuously optimize performance. Your connected tools become a living ecosystem that works smarter with every interaction.
{% endhint %}
## Integrations in Taskade
Integrations connect Taskade to the tools you already use. They run through Automations using **triggers** (events) and **actions** (what happens next).
If you want the bigger model, start with [Workspace DNA](/platform/workspace-dna).
### What you can do
* **Notify and route work**: Slack/Teams alerts, assignments, escalations.
* **Sync data**: push form submissions into a CRM, write rows to Sheets, create tickets.
* **Move faster**: auto-create tasks, summaries, follow-ups, and reports.
* **Close loops**: trigger workflows from app events and write results back into projects.
### Typical workflows
* Lead capture β qualify β create CRM record β notify team
* Support email/webhook β categorize β create ticket β assign owner
* Schedule trigger β generate report β send to stakeholders
### Quick start
1. Connect a tool from the Integrations screen.
2. Create an automation with a trigger + action.
3. Test with real data.
Start here:
* [Automation Getting Started](/automations/automation)
* [Actions & Triggers](/automations/automation/actions)
* [Integration Options](/automations/automation/integrations)
## Popular Integrations
Most teams start with:
* Communication: Slack, Microsoft Teams, email
* Productivity: Google Workspace, Microsoft 365
* Data: Google Sheets, Airtable
* CRM: HubSpot, Salesforce
* Dev: GitHub, Jira
Full list and setup details: [Integration Options](/automations/automation/integrations)
## Advanced Integration Patterns
Start with one trigger and one outcome. Then add steps and branches.
Common patterns:
* Form submission β qualify β create CRM record β notify Slack
* Support email/webhook β categorize β create ticket β assign owner
* Schedule trigger β generate report β send digest
See the full building blocks:
* [Automation Getting Started](/automations/automation)
* [Actions & Triggers](/automations/automation/actions)
## Integration Best Practices
Keep these four things tight:
* **Scope**: grant the minimum permissions you need.
* **Test**: run with real data, not placeholders.
* **Handle failures**: decide what to do when an API call fails.
* **Observe**: monitor errors and retries for critical workflows.
## Custom Integration Development
Donβt see your tool? Use HTTP requests/webhooks or the Taskade API.
Start here:
* [Developer Overview](/developers/developer-home/developers)
* [Actions & Triggers](/automations/automation/actions)
## Getting Started with Integrations
### Planning Your Integration Strategy
Keep it simple:
1. Pick one workflow you want to automate end-to-end.
2. Choose one trigger and one destination tool.
3. Add steps only after the core path works.
### Implementation Checklist
* β
Connect the integration
* β
Build one automation
* β
Test with real data
* β
Add notifications for failure cases
## Support and Resources
Use these when you get stuck:
* Full integration list: [Integration Options](/automations/automation/integrations)
* Workflow basics: [Automation Getting Started](/automations/automation)
* Troubleshooting: [Living System Troubleshooting](/community-and-sharing/community-and-sharing/troubleshooting)
{% hint style="info" %}
**Enterprise Integration Support**: Enterprise customers receive priority support for integrations, including dedicated integration specialists and custom development services.
{% endhint %}
# Integration Options
Connect Taskade automations to 100+ tools like Slack, Gmail, GitHub, HubSpot, and Stripe with triggers and actions, plus custom webhook integrations.
Taskade connects to **100+ tools and services** across communication, productivity, AI, and developer ecosystems with enterprise-grade reliability and global performance. Each integration supports both triggers (events that start automations) and actions (tasks that automations can perform) with enhanced error handling and worldwide data synchronization.
## Enhanced Integration Features
### **Enterprise-Grade Reliability**
* **High availability** across all integrations
* **Advanced error handling** with automatic retries and recovery
* **Real-time monitoring** and alerting for integration health
* **Enhanced security** with additional data protection layers
* **Global performance** with worldwide data synchronization
### **Advanced Integration Capabilities**
* **Intelligent data transformation** with enhanced validation
* **Complex multi-step workflows** spanning multiple services
* **Real-time analytics** and performance insights
* **Enhanced file processing** and document management
* **Improved calendar integration** and scheduling features
## Categories
### Communication & Collaboration
| Service | Triggers | Actions | Authentication |
| --------------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------- |
| **Slack** | New message, mention, reaction | Send message, create channel, update status, invite user | OAuth 2.0 |
| **Microsoft Teams** | New message, new channel message, meeting scheduled | Post message, create meeting, manage channels | OAuth 2.0 |
| **Microsoft Outlook** | New email received | Send email, reply to email, forward email, move email, get email, find email, mark as read | OAuth 2.0 |
| **Discord** | New message, member joined | Send message, manage roles, create invite | Bot Token |
| **WhatsApp Business** | New message received | Send message, send template | API Key |
| **Telegram** | New message, command | Send message, create poll, manage chat | Bot Token |
| **Email (SMTP)** | New email received | Send email, create campaign | SMTP Credentials |
| **Gmail** | New email, label added (including label-filtered), new email matching filter | Send email, reply to email, get email, create draft, add label | OAuth 2.0 |
### Development & Project Management
| Service | Triggers | Actions | Authentication |
| ---------------- | --------------------------------- | -------------------------------------------------------------------------------------------------------------------- | ------------------- |
| **GitHub** | Issue created, PR opened, push | Create issue, comment, merge PR, trigger workflow | OAuth 2.0 / PAT |
| **GitLab** | Issue created, MR opened | Create issue, update MR, trigger pipeline | OAuth 2.0 / PAT |
| **Jira** | Issue created, status changed | Create ticket, update status, assign user | OAuth 2.0 / API Key |
| **Linear** | Issue created, updated | Create issue, update priority, assign | OAuth 2.0 / API Key |
| **Asana** | Task created, completed | Create task, update project, assign | OAuth 2.0 / PAT |
| **ClickUp** | Task created, task status changed | Create task, update task, delete task, add comment, get task, list tasks, find task by name, get task comments | OAuth 2.0 / API Key |
| **Google Tasks** | Task created, task completed | Create task, update task, delete task, complete task, re-open task, list tasks, clear completed, get task, find task | OAuth 2.0 |
| **Monday.com** | Item created, updated | Create item, update status, notify | OAuth 2.0 / API Key |
| **Todoist** | Task completed | Create task, update task, complete task, re-open task, delete task, find task | OAuth 2.0 / API Key |
| **Trello** | Card created, moved | Create card, move card, add member | OAuth 2.0 / API Key |
### Data & Analytics
| Service | Triggers | Actions | Authentication |
| ------------------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------- |
| **Google Sheets** | New row, row updated, cell updated | Add row, update cell, create chart, create spreadsheet | OAuth 2.0 |
| **Airtable** | New record, updated | Create record, update field, link records | OAuth 2.0 / API Key |
| **Google Docs** | New document created | Read document, edit template file | OAuth 2.0 |
| **Google Drive** | New file, file updated | Upload file, create folder, move file, share file, delete file (Shared Drive supported) | OAuth 2.0 |
| **Google Calendar** | Event created, event started | Create event, update event, list events (with search), delete event, add attendee | OAuth 2.0 |
| **Notion** | Page created, updated | Create page, update database, add content | OAuth 2.0 |
| **HubSpot** | Contact created, deal updated | Create contact, upsert contact, search contacts, get contact, update contact, create deal, update deal, search deals, get deal, send email | OAuth 2.0 / API Key |
| **Salesforce** | Lead created, opportunity updated | Create lead, update opportunity, assign | OAuth 2.0 |
| **Pipedrive** | Deal created, activity added | Create deal, add activity, update stage | OAuth 2.0 / API Key |
| **Custom Webhooks** | Webhook received | Send HTTP request, trigger workflow | API Key / Bearer Token |
### Marketing & Sales
| Service | Triggers | Actions | Authentication |
| --------------- | --------------------------------------- | ------------------------------------------------- | ------------------- |
| **Mailchimp** | Subscriber added, campaign sent | Add subscriber, send campaign, create list | OAuth 2.0 / API Key |
| **ConvertKit** | Subscriber added, tag applied | Add subscriber, create sequence, send broadcast | OAuth 2.0 / API Key |
| **Calendly** | Event scheduled, cancelled | Create event, update availability, send reminder | OAuth 2.0 / API Key |
| **Stripe** | Payment succeeded, subscription created | Create customer, process payment, send receipt | OAuth 2.0 / API Key |
| **PayPal** | Payment completed, dispute opened | Process payment, send invoice, refund | OAuth 2.0 / API Key |
| **Shopify** | Order created, product updated | Create order, update inventory, send notification | OAuth 2.0 / API Key |
| **WooCommerce** | Order placed, customer registered | Update order, manage inventory, send email | REST API / API Key |
### Web & Content
| Service | Triggers | Actions | Authentication |
| ---------------- | --------------------------------- | ---------------------------------------------------------------------------------- | ------------------- |
| **Twitter/X** | Mention detected | Post tweet, reply to tweet, delete post, retweet, post tweet with image attachment | OAuth 2.0 |
| **WordPress** | New post published, comment added | Create post with featured image, update content, moderate comment | OAuth 2.0 / API Key |
| **Webflow** | Form submitted, item published | Create CMS item, update content, publish | OAuth 2.0 / API Key |
| **Typeform** | Form submitted, response updated | Create form, update response, send email | OAuth 2.0 / PAT |
| **Google Forms** | Form submitted | Create form, add response, send notification | OAuth 2.0 |
| **RSS Feeds** | New item published | Parse content, extract data, trigger workflow | URL |
| **YouTube** | Video uploaded, comment added | Upload video, update metadata, respond | OAuth 2.0 / API Key |
| **Medium** | Story published, clap received | Publish story, update profile, send response | OAuth 2.0 / API Key |
### Custom & Developer
| Service | Triggers | Actions | Authentication |
| --------------------------------- | ----------------------- | ----------------------------------------------------------------------------------------------------- | ----------------------------------- |
| **HTTP Webhooks** | Webhook received | Send HTTP request, POST data, call API | Optional (Bearer / API Key / Basic) |
| **IFTTT / Apple Shortcuts / n8n** | Webhook received | Call any of them via the HTTP request action β they're discoverable when searching automation actions | Webhook URL |
| **REST APIs** | Custom endpoint called | Make API call, send data, receive response | Various |
| **GraphQL** | Query executed | Execute query, mutation, subscription | API Key / OAuth |
| **Custom Forms** | Form submitted | Process data, validate, route to workflow | None |
| **Database** | Record created, updated | Insert record, update data, run query | Connection String |
| **FTP/SFTP** | File uploaded, modified | Upload file, download, sync directory | Credentials |
> **Related developer docs:** Build custom integrations programmatically with the [Developer Hub](/developers/developer-home) and [Webhooks](/developers/webhooks), or contribute to the open-source [Integration Kit](https://github.com/taskade/integrations) (Zapier & n8n actions and triggers).
## Integration Setup
### 1. **Authentication**
Most integrations require authentication to access your accounts:
* **OAuth 2.0**: Secure authorization flow (recommended)
* **API Keys**: Simple token-based authentication
* **Personal Access Tokens**: User-specific tokens with limited scope
### 2. **Configuration**
Each integration has specific configuration options:
* **Endpoints**: Which API endpoints to use
* **Data Mapping**: How to map fields between systems
* **Rate Limits**: Respect service limitations
* **Error Handling**: What to do when requests fail
### 3. **Testing**
Before deploying automations:
* Test with sample data
* Verify authentication works
* Check data mapping accuracy
* Monitor for errors and edge cases
## Popular Integration Patterns
### **CRM Sync**
```
Form Submission β AI Lead Qualification β HubSpot Deal Creation β Slack Notification
```
### **Support Ticket Routing**
```
Email/Webhook β AI Categorization β Jira Ticket Creation β Team Assignment
```
### **Content Publishing**
```
Schedule Trigger β AI Content Generation β Review Process β WordPress Publication
```
### **Project Management**
```
GitHub Issue β AI Analysis β Taskade Task Creation β Team Notification
```
### **Data Processing**
```
Google Sheets Update β AI Data Enrichment β Airtable Record Creation β Report Generation
```
## Advanced Features
### **Conditional Routing**
Route data to different services based on content, priority, or other criteria.
### **Data Transformation**
Clean, format, and enrich data as it flows between systems.
### **Error Recovery**
Automatically retry failed requests and handle service outages gracefully.
### **Rate Limiting**
Respect API limits and queue requests when necessary.
### **Batch Processing**
Process multiple records efficiently to reduce API calls.
## Custom Integrations
Don't see your service listed? You can create custom integrations using:
### **HTTP Webhooks**
* Send data to any REST API
* Receive webhooks from external services
* Custom authentication headers
* JSON/XML data formatting
### **Database Connections**
* Connect to PostgreSQL, MySQL, MongoDB
* Execute custom queries
* Sync data bidirectionally
* Handle large datasets efficiently
### **File Processing**
* Upload/download files via FTP/SFTP
* Process CSV, JSON, XML files
* Image and document processing
* Cloud storage integration
## Detailed Integration Examples
### Google Calendar Integration
**Automatic Event Creation:**
* **Trigger:** Task with due date added
* **Action:** Create Google Calendar event
* **Use Case:** Never miss project deadlines
**Meeting Follow-up:**
* **Trigger:** Calendar event ends
* **Action:** Create follow-up tasks in Taskade
* **Use Case:** Ensure meeting action items are tracked
**Project Milestone Sync:**
* **Trigger:** Project phase completed
* **Action:** Update calendar with next milestone
* **Use Case:** Keep stakeholders informed of progress
### Google Sheets Integration
**Data Collection:**
* **Trigger:** Form submission
* **Action:** Add row to Google Sheets
* **Use Case:** Centralized data tracking and analysis
**Inventory Management:**
* **Trigger:** Task completed (inventory check)
* **Action:** Update stock levels in spreadsheet
* **Use Case:** Real-time inventory tracking
**Performance Reporting:**
* **Trigger:** Weekly schedule
* **Action:** Generate report from Taskade data to Sheets
* **Use Case:** Automated team performance dashboards
### Social Media Integrations
**LinkedIn Content Sharing:**
* **Trigger:** Content approved in review project
* **Action:** Post to LinkedIn company page
* **Use Case:** Automated content distribution
**Twitter/X Engagement:**
* **Trigger:** Mention detected
* **Action:** Create task for social media manager
* **Use Case:** Never miss customer interactions
**YouTube Content Workflow:**
* **Trigger:** Video uploaded
* **Action:** Create promotion tasks and schedule posts
* **Use Case:** Comprehensive video marketing automation
### WhatsApp Business Integration
WhatsApp Business integration enhances your communication strategy by automating customer interactions, managing inquiries, and enabling AI-powered responses.
#### **Setup & Configuration**
1. **Connect WhatsApp Business Account** - Link your verified business account
2. **Configure System User Access Token** - Set up API authentication
3. **Verify Business Account ID** - Ensure proper account linking
4. **Test Connection** - Send test message to verify setup
#### **Available Actions**
| Action | Description | Parameters | Use Case |
| ------------------------- | ----------------------------- | ------------------------------------------------- | ------------------------------------------ |
| **Send Message** | Send text message to contact | `phoneNumber`, `message`, `messageType` | Customer notifications, support responses |
| **Send Template Message** | Send pre-approved template | `templateId`, `phoneNumber`, `variables` | Order confirmations, appointment reminders |
| **Send Media Message** | Send images, documents, audio | `phoneNumber`, `mediaUrl`, `mediaType`, `caption` | Product catalogs, instruction manuals |
| **Get Message Status** | Check delivery status | `messageId` | Track message delivery and read receipts |
#### **Real-World Use Cases**
**Customer Support Automation:**
* **Trigger:** WhatsApp message received
* **Action:** Create support ticket, auto-reply with case number
* **AI Enhancement:** Sentiment analysis, automatic categorization
* **Follow-up:** Route to appropriate specialist based on message content
**Order Management:**
* **Trigger:** Order status changed in system
* **Action:** Send WhatsApp notification with tracking info
* **Personalization:** Include customer name, order details, estimated delivery
* **Escalation:** Alert if delivery is delayed
**Lead Qualification:**
* **Trigger:** WhatsApp message from new contact
* **Action:** Run AI agent to qualify lead, update CRM
* **Automation:** Schedule follow-up, assign to sales rep
* **Integration:** Sync with HubSpot, Salesforce, or other CRM
**Appointment Reminders:**
* **Trigger:** 24 hours before appointment
* **Action:** Send WhatsApp reminder with appointment details
* **Options:** Include reschedule link, location map
* **Confirmation:** Request confirmation reply, update calendar
***
## **Enterprise Integration Patterns**
### **Advanced CRM Workflows**
**HubSpot Revenue Operations**
```yaml
Lead Qualification Pipeline:
Trigger: Form submission or LinkedIn connection
Step 1 - Data Enrichment:
- Agent analyzes lead profile and company
- Enriches contact with industry, size, tech stack
- Scores lead based on ideal customer profile
Step 2 - Intelligent Routing:
- High-value leads β Senior sales rep
- SMB leads β Inside sales team
- Enterprise β Account executive
- Poor fit β Marketing nurture sequence
Step 3 - Automated Follow-up:
- Personalized email based on lead profile
- LinkedIn connection request with custom message
- Calendar link for qualified prospects
- Task creation for sales rep with context
Outcome: More qualified meetings booked, faster first response
```
**Salesforce Account Management**
```yaml
Customer Success Automation:
Trigger: Contract renewal date approaching (90 days)
Workflow:
- Agent analyzes account health score
- Generates renewal strategy document
- Creates tasks for CSM with talking points
- Schedules automated check-in sequence
- Alerts if risk factors detected
- Prepares expansion opportunity analysis
Outcome: Better renewal rates and expansion revenue through timely outreach
```
### **Microsoft Teams Enterprise Communication**
**Crisis Communication System**
```yaml
Emergency Response Protocol:
Trigger: Critical system alert or security incident
Immediate Actions:
- Create dedicated Teams channel for incident
- Send alert to on-call team with severity level
- Generate incident response checklist
- Start video call with key stakeholders
- Document timeline in shared project
- Update status page automatically
Recovery Actions:
- Collect post-mortem feedback via forms
- Generate incident report with AI analysis
- Schedule follow-up meetings
- Update runbooks based on learnings
```
**Executive Briefing Automation**
```yaml
Daily Executive Dashboard:
Schedule: Every morning at 7 AM
Data Collection:
- Pull KPIs from multiple systems
- Analyze team productivity metrics
- Review customer satisfaction scores
- Check financial performance indicators
- Monitor security and compliance status
Report Generation:
- AI agent creates executive summary
- Highlights key achievements and concerns
- Provides actionable recommendations
- Formats for mobile consumption
Distribution:
- Send to executive Teams channel
- Create calendar event for leadership meeting
- Archive in executive workspace
```
### **Advanced Marketing Automation**
**LinkedIn Content Amplification**
```yaml
Content Distribution Engine:
Trigger: New blog post published
Content Strategy:
- Agent analyzes post for key themes
- Generates LinkedIn post variations
- Creates different versions for executives vs employees
- Schedules posts across team members
- Monitors engagement and adjusts timing
Engagement Management:
- Responds to comments with brand voice
- Identifies potential leads in comments
- Creates follow-up tasks for sales team
- Tracks content performance metrics
```
**Multi-Channel Campaign Orchestration**
```yaml
Product Launch Campaign:
Trigger: Product launch date set
Pre-Launch (30 days):
- Create LinkedIn teaser content
- Set up Facebook ad campaigns
- Generate press release and media kit
- Schedule influencer outreach
- Prepare customer email sequences
Launch Day:
- Coordinate social media posts across platforms
- Send announcement emails to segments
- Update website and product pages
- Activate PR outreach sequence
- Monitor mentions and engagement
Post-Launch (30 days):
- Analyze campaign performance
- Generate success metrics report
- Create case studies from early customers
- Plan follow-up campaigns
- Archive assets for future use
```
### **Financial Operations Integration**
**Automated Invoice Processing**
```yaml
Accounts Payable Workflow:
Trigger: Invoice received via email or upload
Processing:
- AI agent extracts invoice data
- Validates against purchase orders
- Routes for approval based on amount
- Sends to QuickBooks/Xero for payment
- Updates project budgets automatically
- Notifies stakeholders of status changes
Exception Handling:
- Flags discrepancies for human review
- Escalates overdue approvals
- Tracks vendor performance metrics
- Generates compliance reports
```
**Revenue Recognition Automation**
```yaml
SaaS Revenue Tracking:
Trigger: New subscription or upgrade
Revenue Actions:
- Calculate monthly recurring revenue
- Update financial forecasts
- Create revenue recognition schedule
- Sync with accounting systems
- Generate investor reporting data
- Alert finance team of significant changes
```
### **Human Resources Automation**
**Employee Lifecycle Management**
```yaml
Onboarding Automation:
Trigger: New hire start date confirmed
Pre-boarding (1 week before):
- Send welcome package and handbook
- Create accounts in all systems
- Order equipment and prepare workspace
- Schedule first-day meetings
- Add to team communication channels
First Day:
- Send welcome message to team
- Create onboarding checklist project
- Schedule check-ins with manager
- Assign buddy/mentor
- Begin training sequence
First Month:
- Track onboarding progress
- Collect feedback via surveys
- Schedule HR check-ins
- Monitor training completion
- Generate manager reports
```
**Performance Review Automation**
```yaml
360-Degree Review Process:
Trigger: Review cycle start date
Preparation:
- Generate review forms for each employee
- Collect peer feedback requests
- Analyze performance data from systems
- Create manager briefing documents
- Schedule review meetings
Execution:
- Send automated reminders
- Compile feedback from multiple sources
- Generate performance summaries
- Create development recommendations
- Track completion rates
Follow-up:
- Create development plans
- Set goals for next period
- Schedule follow-up meetings
- Archive review documents
- Generate HR analytics
```
## Getting Help
### **Documentation**
Each integration has detailed setup guides and examples in our help center.
### **Community**
Join our developer community to share integration patterns and get help.
### **Support**
Enterprise customers get priority support for custom integrations.
***
> **Need a custom integration?**\
> β [Contact our team](https://taskade.com/contact) for enterprise solutions
> **Want to contribute an integration?**\
> β Open a PR on the open-source [Integration Kit](https://github.com/taskade/integrations) (Zapier & n8n actions and triggers), or [share ideas](https://taskade.com/community) with the community
β **Next:** [**Browse Actions & Triggers**](/automations/automation/actions)\
β **Complete Reference:** [**Comprehensive Automation Integrations**](/automations/automation/comprehensive-integrations)
# Automation Recipes
Ready-to-use Taskade automation recipes with full JSON configs: AI blog publishing, social posting, lead capture, ticket routing, GitHub sync, and cart.
Real-world automation workflows that you can implement immediately. Each recipe includes the complete configuration, setup instructions, and customization options.
## Content Creation & Marketing
### Recipe 1: Daily Blog Article Generator
{% hint style="success" %}
Automatically generate and publish blog articles from titles using AI agents and WordPress integration. Perfect for content marketers and bloggers who need consistent publishing.
{% endhint %}
**Use Case**: Turn article titles into full blog posts automatically, then publish them to WordPress on a daily schedule.
**Workflow**: Daily Schedule β Find Unprocessed Titles β Generate Articles β Publish to WordPress β Update Status
**Setup Requirements**:
* AI Blog Writing Agent (created via Agent Generator)
* WordPress integration configured
* Taskade project with custom fields for tracking post status
* Article titles stored as tasks in the project
```json
{
"name": "Daily Blog Article Generator",
"trigger": {
"type": "schedule.daily",
"time": "09:00",
"timezone": "America/New_York"
},
"actions": [
{
"type": "findTasks",
"projectId": "blog_content_tracker",
"filters": {
"customField": {
"post_status": {
"not_equals": "posted"
}
}
},
"returnType": "array",
"limit": 5
},
{
"type": "loop.forEach",
"array": "{{steps.0.tasks}}",
"actions": [
{
"type": "agent.runCommand",
"agentId": "blog_writer_agent",
"command": "write_full_article",
"input": {
"title": "{{loop.item.name}}",
"word_count": "1500",
"tone": "professional",
"include_images": true
}
},
{
"type": "createProject",
"name": "{{loop.item.name}}",
"content": "{{steps.1.output}}",
"tags": ["blog", "auto-generated"]
},
{
"type": "wordpress.createPost",
"title": "{{loop.item.name}}",
"content": "{{steps.1.output}}",
"status": "publish",
"categories": ["blog"],
"tags": ["automated", "ai-generated"]
},
{
"type": "updateCustomField",
"taskId": "{{loop.item.id}}",
"fieldName": "post_status",
"value": "posted"
},
{
"type": "updateCustomField",
"taskId": "{{loop.item.id}}",
"fieldName": "wordpress_url",
"value": "{{steps.3.postUrl}}"
}
]
}
]
}
```
**Setup Instructions**:
{% stepper %}
{% step %}
#### Create Blog Writing Agent
Use the AI Agent Generator to create a "Blog Writer" agent. Train it with examples of your blog style and content guidelines.
{% endstep %}
{% step %}
#### Set Up Content Tracking Project
Create a Taskade project called "Blog Content Tracker" with custom fields:
* `post_status` (dropdown: draft, generated, posted)
* `wordpress_url` (text field for published URL)
* `target_word_count` (number)
* `target_publish_date` (date)
{% endstep %}
{% step %}
#### Configure WordPress Integration
Connect your WordPress site to Taskade and ensure proper permissions for post creation.
{% endstep %}
{% step %}
#### Create the Automation
Build the automation with daily scheduling, task finding, looping, and WordPress publishing actions.
{% endstep %}
{% step %}
#### Test and Refine
Start with one article, review the output, and adjust the agent prompts or automation logic as needed.
{% endstep %}
{% endstepper %}
**Customization Options**:
* **Scheduling**: Change frequency from daily to weekly or custom intervals
* **Content Types**: Modify for social media posts, newsletters, or other content formats
* **Quality Control**: Add human review steps before publishing
* **Multi-platform**: Extend to publish to Medium, LinkedIn, or other platforms
* **SEO Optimization**: Include keyword research and meta description generation
### Recipe 2: Automated Social Media Posting
{% hint style="success" %}
Schedule and automate social media posts using due dates and custom fields. Perfect for social media managers and digital marketers who need consistent posting schedules.
{% endhint %}
**Use Case**: Automatically post content to social media platforms (like X/Twitter) when tasks reach their due date, maintaining consistent online presence.
**Workflow**: Task Due β Post to Social Media β Update Status β Track Performance
**Setup Requirements**:
* Taskade project with social media content
* Custom fields for tracking post status
* Social media integration (Twitter/X, LinkedIn, Facebook)
* Due dates set on tasks for scheduling
**Example Project Structure:**
```
π± Social Media Content Calendar βββ π Post Content (task description) βββ π
Due Date (posting schedule) βββ π Status (Draft β Scheduled β Posted) βββ π Platform (Twitter, LinkedIn, Facebook) βββ π― Target Audience
```
```json
{
"name": "Social Media Auto-Poster",
"trigger": {
"type": "task.due",
"projectId": "social_media_calendar",
"filters": {
"customField": {
"status": {
"equals": "scheduled"
}
}
}
},
"actions": [
{
"type": "conditional",
"condition": "@trigger.task.customFields.platform == 'twitter'",
"actions": [
{
"type": "twitter.createPost",
"content": "@trigger.task.content",
"account": "main_account"
}
]
},
{
"type": "conditional",
"condition": "@trigger.task.customFields.platform == 'linkedin'",
"actions": [
{
"type": "linkedin.createPost",
"content": "@trigger.task.content",
"account": "company_page"
}
]
},
{
"type": "updateCustomField",
"taskId": "@trigger.task.id",
"fieldName": "status",
"value": "posted"
},
{
"type": "updateCustomField",
"taskId": "@trigger.task.id",
"fieldName": "posted_at",
"value": "@current.timestamp"
}
]
}
```
**Setup Instructions:**
{% stepper %}
{% step %}
#### Create Content Calendar Project
Set up a Taskade project using Table view to organize your social media content
{% endstep %}
{% step %}
#### Add Custom Fields
Create fields for Status (dropdown: draft, scheduled, posted), Platform, and Posted\_At (date)
{% endstep %}
{% step %}
#### Set Up Automation Trigger
Create a "Task Due" trigger that fires when content is scheduled to post
{% endstep %}
{% step %}
#### Configure Social Media Actions
Add conditional actions for each platform (Twitter, LinkedIn, Facebook) based on custom field values
{% endstep %}
{% step %}
#### Add Status Updates
Include actions to update the task status and posting timestamp after successful publication
{% endstep %}
{% endstepper %}
**Platform-Specific Configuration:**
| **Platform** | **Integration Required** | **Content Limits** | **Best Practices** |
| ------------- | ------------------------ | ------------------ | ---------------------------------------- |
| **Twitter/X** | Twitter API connection | 280 characters | Use hashtags, engage with trends |
| **LinkedIn** | LinkedIn Business API | 3000 characters | Professional tone, industry insights |
| **Facebook** | Facebook Graph API | 63206 characters | Visual content, community engagement |
| **Instagram** | Meta Business API | 2200 characters | High-quality images, Stories integration |
**Advanced Features:**
{% hint style="info" %}
**Multi-Platform Posting**: Set up conditional logic to post the same content across multiple platforms simultaneously.
{% endhint %}
**Content Personalization:**
* Use variables to customize posts for different audiences
* Include platform-specific hashtags and formatting
* Adapt tone and style based on target platform
**Analytics Integration:**
* Track engagement metrics automatically
* Update performance data in Taskade
* Generate posting reports and insights
**Bulk Scheduling:**
* Import content calendars from spreadsheets
* Schedule multiple posts at once
* Use recurring tasks for consistent posting
**Customization Options:**
* **Content Variations**: Create platform-specific versions of posts
* **Timing Optimization**: Use analytics to determine best posting times
* **A/B Testing**: Test different content approaches
* **Approval Workflows**: Add review steps before posting
* **Performance Tracking**: Monitor engagement and adjust strategies
## Lead Generation & Sales
### Recipe 3: Lead Capture & Qualification
**Use Case**: Automatically capture leads from your website form, qualify them with AI, and route to the appropriate sales team.
**Workflow**: Form Submission β AI Qualification β CRM Creation β Team Notification
```json
{
"name": "Lead Capture & Qualification",
"trigger": {
"type": "form.submitted",
"form_name": "Contact Form"
},
"actions": [
{
"type": "agent.runCommand",
"agentId": "lead_qualifier",
"command": "qualify_lead",
"input": {
"name": "{{form.name}}",
"email": "{{form.email}}",
"company": "{{form.company}}",
"message": "{{form.message}}"
}
},
{
"type": "hubspot.createContact",
"email": "{{form.email}}",
"firstName": "{{form.name}}",
"company": "{{form.company}}",
"properties": {
"lead_score": "{{previous.score}}",
"qualification_notes": "{{previous.notes}}"
}
},
{
"type": "condition.if",
"condition": "{{steps.0.score}} >= 80",
"then": [
{
"type": "slack.sendMessage",
"channel": "#sales-hot-leads",
"message": "π₯ Hot lead: {{form.name}} from {{form.company}} (Score: {{steps.0.score}})"
},
{
"type": "hubspot.createTask",
"contactId": "{{steps.1.id}}",
"title": "Follow up with hot lead",
"dueDate": "{{now + 1 hour}}"
}
],
"else": [
{
"type": "email.sendTemplate",
"to": "{{form.email}}",
"templateId": "nurture_sequence_start",
"variables": {
"name": "{{form.name}}",
"company": "{{form.company}}"
}
}
]
}
]
}
```
**Setup Instructions**:
1. Create a lead qualification agent with prompts for scoring leads based on company size, industry, and message content.
2. Connect your HubSpot and Slack integrations in Taskade.
3. Create an email template in your email service with the ID `nurture_sequence_start`.
4. Create a public Taskade form titled "Contact Form" with `name`, `email`, `company`, and `message` fields.
### Recipe 4: Deal Stage Automation
**Use Case**: Automatically update deal stages based on customer actions and notify relevant team members.
```json
{
"name": "Deal Stage Automation",
"trigger": {
"type": "hubspot.dealUpdated",
"filters": {
"stage": "proposal_sent"
}
},
"actions": [
{
"type": "schedule.delay",
"delay": "3 days"
},
{
"type": "condition.if",
"condition": "{{deal.stage}} === 'proposal_sent'",
"then": [
{
"type": "email.send",
"to": "{{deal.contact.email}}",
"subject": "Following up on your proposal",
"template": "proposal_followup"
},
{
"type": "slack.sendMessage",
"channel": "#sales",
"message": "π§ Follow-up sent to {{deal.contact.name}} for deal: {{deal.name}}"
}
]
}
]
}
```
**Setup Instructions**:
1. Connect your HubSpot, Email, and Slack integrations.
2. Ensure your HubSpot deal pipeline has a stage named "proposal\_sent".
3. Create an email template named `proposal_followup`.
## Customer Support
### Recipe 5: Intelligent Ticket Routing
**Use Case**: Automatically categorize support tickets and route them to the right team with appropriate priority.
```json
{
"name": "Intelligent Ticket Routing",
"trigger": {
"type": "email.received",
"filters": {
"to": "support@company.com"
}
},
"actions": [
{
"type": "agent.runCommand",
"agentId": "support_classifier",
"command": "categorize_ticket",
"input": {
"subject": "{{email.subject}}",
"body": "{{email.body}}",
"from": "{{email.from}}"
}
},
{
"type": "taskade.createTask",
"projectId": "{{previous.project_id}}",
"title": "{{email.subject}}",
"content": "**From**: {{email.from}}\n**Category**: {{previous.category}}\n**Priority**: {{previous.priority}}\n\n{{email.body}}",
"priority": "{{previous.priority}}",
"assignee": "{{previous.assignee}}"
},
{
"type": "condition.switch",
"value": "{{steps.0.priority}}",
"cases": {
"urgent": [
{
"type": "slack.sendMessage",
"channel": "#support-urgent",
"message": "π¨ Urgent ticket: {{email.subject}} from {{email.from}}"
}
],
"high": [
{
"type": "slack.sendMessage",
"channel": "#support",
"message": "β οΈ High priority ticket: {{email.subject}} assigned to {{steps.0.assignee}}"
}
]
}
}
]
}
```
**Setup Instructions**:
1. Create a "Support Classifier" agent trained to analyze ticket content and output a structured JSON with `project_id`, `category`, `priority`, and `assignee`.
2. Connect your email and Slack integrations.
3. Set up Taskade projects corresponding to the `project_id` your agent will return.
## Content Operations
### Recipe 6: Content Creation Pipeline
**Use Case**: Generate blog content ideas, create drafts, and manage the approval process.
```json
{
"name": "Content Creation Pipeline",
"trigger": {
"type": "schedule.weekly",
"day": "monday",
"time": "09:00"
},
"actions": [
{
"type": "agent.runCommand",
"agentId": "content_researcher",
"command": "research_trending_topics",
"input": {
"industry": "technology",
"audience": "developers",
"count": 5
}
},
{
"type": "loop.forEach",
"array": "{{previous.topics}}",
"actions": [
{
"type": "taskade.createTask",
"projectId": "content_calendar",
"title": "Write: {{item.title}}",
"content": "**Keywords**: {{item.keywords}}\n**Outline**: {{item.outline}}",
"assignee": "content_team"
}
]
}
]
}
```
## Development & Project Management
### Recipe 7: GitHub Issue to Project Task
**Use Case**: Automatically create project tasks from GitHub issues and sync status updates.
```json
{
"name": "GitHub Issue to Project Task",
"trigger": {
"type": "github.issueOpened",
"repository": "company/product"
},
"actions": [
{
"type": "agent.runCommand",
"agentId": "issue_analyzer",
"command": "analyze_issue",
"input": {
"title": "{{issue.title}}",
"body": "{{issue.body}}",
"labels": "{{issue.labels}}"
}
},
{
"type": "taskade.createTask",
"projectId": "{{previous.project_id}}",
"title": "{{issue.title}}",
"content": "**GitHub Issue**: {{issue.html_url}}\n**Priority**: {{previous.priority}}\n\n{{issue.body}}",
"assignee": "{{previous.assignee}}"
}
]
}
```
## Data Processing & Analytics
### Recipe 8: Weekly Analytics Report
**Use Case**: Generate and distribute weekly analytics reports to stakeholders.
```json
{
"name": "Weekly Analytics Report",
"trigger": {
"type": "schedule.weekly",
"day": "friday",
"time": "17:00"
},
"actions": [
{
"type": "agent.runCommand",
"agentId": "analytics_agent",
"command": "generate_weekly_report",
"input": {
"start_date": "{{now - 7 days}}",
"end_date": "{{now}}",
"metrics": ["traffic", "conversions", "revenue"]
}
},
{
"type": "email.send",
"to": ["team@company.com"],
"subject": "Weekly Analytics Report",
"body": "{{previous.formatted_report}}"
}
]
}
```
## HR & Operations
### Recipe 9: Employee Onboarding Automation
**Use Case**: Automate the employee onboarding process with task creation and notifications.
```json
{
"name": "Employee Onboarding Automation",
"trigger": {
"type": "form.submitted",
"form_name": "New Employee Form"
},
"actions": [
{
"type": "taskade.createProject",
"name": "{{form.employee_name}} - Onboarding",
"template": "employee_onboarding_template"
},
{
"type": "email.sendTemplate",
"to": "{{form.employee_email}}",
"templateId": "welcome_email",
"variables": {
"name": "{{form.employee_name}}",
"start_date": "{{form.start_date}}"
}
}
]
}
```
## E-commerce & Sales
### Recipe 10: Abandoned Cart Recovery
**Use Case**: Automatically follow up with customers who abandon their shopping carts.
```json
{
"name": "Abandoned Cart Recovery",
"trigger": {
"type": "shopify.cartAbandoned",
"filters": {
"cart_value": "> 50"
}
},
"actions": [
{
"type": "schedule.delay",
"delay": "1 hour"
},
{
"type": "email.sendTemplate",
"to": "{{cart.customer.email}}",
"templateId": "abandoned_cart_recovery",
"variables": {
"customer_name": "{{cart.customer.name}}",
"cart_url": "{{cart.recovery_url}}"
}
}
]
}
```
## Custom Recipe Builder
### Template Structure
```json
{
"name": "Your Recipe Name",
"description": "What this automation does",
"trigger": {
"type": "trigger_type",
"filters": {},
"config": {}
},
"actions": [
{
"type": "action_type",
"parameters": {}
}
]
}
```
### Best Practices
1. **Start Simple**: Begin with basic trigger-action pairs
2. **Add Conditions**: Use conditional logic for complex workflows
3. **Handle Errors**: Always include error handling and retries
4. **Test Thoroughly**: Test with sample data before deployment
5. **Monitor Performance**: Track automation success rates and timing
***
> **Need help with a custom recipe?**\
> β [Join our community](https://taskade.com/community) for support and examples
> **Want to share your recipe?**\
> β [Browse the Taskade template gallery](https://www.taskade.com/templates)
β **Next:** [**Set up your first automation**](/#getting-started)
# Advanced Actions
Build advanced Taskade automations with loop and batch actions, WhatsApp Business messaging, HTTP schema generation, retries, and error handling.
**Master the latest automation capabilities including loop processing, WhatsApp Business integration, AI-powered schema generation, and advanced error handling. These powerful features transform complex workflows into simple, reliable automations.**
{% hint style="success" %}
**New in 2025!** Loop actions, WhatsApp Business messaging, HTTP schema auto-generation, and enhanced social media integrations make Taskade automations even more powerful.
{% endhint %}
***
## Loop Actions & Batch Processing
### **What Are Loop Actions?**
Loop actions enable batch processing and nested automation workflows, allowing you to process multiple items, repeat actions, and create sophisticated multi-step processes.
### **Loop Types**
#### **1. For Each Loop**
Process each item in a list or array:
```json
{
"type": "loop.forEach",
"input": "{{webhook.customer_list}}",
"actions": [
{
"type": "crm.updateContact",
"contactId": "{{item.id}}",
"properties": {
"lastEngagement": "{{now}}",
"status": "processed"
}
},
{
"type": "email.send",
"to": "{{item.email}}",
"template": "engagement_update",
"variables": {
"name": "{{item.name}}"
}
}
],
"options": {
"maxConcurrency": 5,
"delayBetweenItems": "2s",
"continueOnError": true
}
}
```
#### **2. While Loop**
Repeat actions until a condition is met:
```json
{
"type": "loop.while",
"condition": "{{api_response.hasMore}} === true",
"maxIterations": 50,
"actions": [
{
"type": "http.get",
"url": "https://api.example.com/data",
"params": {
"page": "{{loop.iteration}}",
"limit": 100
}
},
{
"type": "data.append",
"target": "collected_data",
"value": "{{response.data}}"
}
]
}
```
#### **3. Retry Loop**
Automatically retry failed operations with exponential backoff:
```json
{
"type": "loop.retry",
"maxRetries": 3,
"retryDelay": "5s",
"exponentialBackoff": true,
"retryConditions": ["network_error", "rate_limit", "timeout"],
"actions": [
{
"type": "http.post",
"url": "https://api.external-service.com/webhook",
"payload": "{{form.data}}"
}
],
"onFinalFailure": [
{
"type": "slack.notify",
"channel": "#alerts",
"message": "Failed to sync data after 3 attempts: {{error.message}}"
}
]
}
```
### **Advanced Loop Features**
#### **Nested Loops**
```json
{
"type": "loop.forEach",
"input": "{{projects}}",
"actions": [
{
"type": "loop.forEach",
"input": "{{item.tasks}}",
"actions": [
{
"type": "task.update",
"taskId": "{{item.id}}",
"status": "reviewed"
}
]
}
]
}
```
#### **Loop Control & Break Conditions**
```json
{
"type": "loop.forEach",
"input": "{{candidates}}",
"breakWhen": "{{item.score}} >= 90",
"actions": [
{
"type": "crm.scoreCandidate",
"candidateId": "{{item.id}}"
}
],
"onBreak": [
{
"type": "email.notify",
"message": "Found high-scoring candidate: {{item.name}}"
}
]
}
```
***
## WhatsApp Business Integration
### **Setup & Authentication**
#### **WhatsApp Business API Configuration**
```json
{
"whatsapp": {
"provider": "whatsapp_business",
"config": {
"phoneNumberId": "your_phone_number_id",
"accessToken": "your_whatsapp_access_token",
"businessAccountId": "your_business_account_id"
},
"webhook": {
"verifyToken": "your_verify_token",
"callbackUrl": "https://your-domain.com/whatsapp/webhook"
}
}
}
```
{% hint style="info" %}
**Building your own webhook receiver?** See the developer [Webhooks reference](/developers/webhooks) for payload formats and event types.
{% endhint %}
### **Message Types & Templates**
#### **Text Messages**
```json
{
"type": "whatsapp.sendMessage",
"to": "{{form.phone_number}}",
"messageType": "text",
"content": {
"text": "Hi {{form.name}}! Thanks for your inquiry about {{form.service}}. We'll get back to you within 24 hours."
}
}
```
#### **Template Messages**
```json
{
"type": "whatsapp.sendTemplate",
"to": "{{contact.phone}}",
"template": {
"name": "appointment_reminder",
"language": "en_US",
"parameters": [
{
"type": "text",
"text": "{{appointment.date}}"
},
{
"type": "text",
"text": "{{appointment.time}}"
}
]
}
}
```
#### **Interactive Messages**
```json
{
"type": "whatsapp.sendInteractive",
"to": "{{customer.phone}}",
"interactive": {
"type": "button",
"header": {
"type": "text",
"text": "Order Status Update"
},
"body": {
"text": "Your order #{{order.id}} is ready for pickup!"
},
"action": {
"buttons": [
{
"type": "reply",
"reply": {
"id": "confirm_pickup",
"title": "Confirm Pickup"
}
},
{
"type": "reply",
"reply": {
"id": "request_delivery",
"title": "Request Delivery"
}
}
]
}
}
}
```
#### **Media Messages**
```json
{
"type": "whatsapp.sendMedia",
"to": "{{recipient.phone}}",
"media": {
"type": "image",
"url": "{{product.image_url}}",
"caption": "Check out our new {{product.name}}! Available now for ${{product.price}}"
}
}
```
### **Advanced WhatsApp Workflows**
#### **Customer Support Automation**
```json
{
"name": "WhatsApp Support Flow",
"trigger": {
"type": "whatsapp.messageReceived"
},
"actions": [
{
"type": "ai.analyzeMessage",
"input": "{{message.text}}",
"analysis": ["intent", "urgency", "sentiment"]
},
{
"type": "condition.switch",
"value": "{{ai.intent}}",
"cases": {
"order_status": [
{
"type": "database.lookup",
"table": "orders",
"query": {
"phone": "{{message.from}}"
}
},
{
"type": "whatsapp.sendMessage",
"to": "{{message.from}}",
"content": {
"text": "Your order #{{order.id}} is {{order.status}}. Expected delivery: {{order.delivery_date}}"
}
}
],
"complaint": [
{
"type": "whatsapp.sendMessage",
"to": "{{message.from}}",
"content": {
"text": "I'm sorry to hear about your experience. Let me connect you with a manager who can help resolve this immediately."
}
},
{
"type": "slack.notify",
"channel": "#customer-support",
"message": "Urgent: WhatsApp complaint from {{message.from}}: {{message.text}}"
}
]
}
}
]
}
```
#### **E-commerce Integration**
```json
{
"name": "WhatsApp E-commerce Flow",
"trigger": {
"type": "ecommerce.orderPlaced"
},
"actions": [
{
"type": "whatsapp.sendTemplate",
"to": "{{order.customer.phone}}",
"template": {
"name": "order_confirmation",
"parameters": [
"{{order.id}}",
"{{order.total}}",
"{{order.estimated_delivery}}"
]
}
},
{
"type": "delay.wait",
"duration": "1 day"
},
{
"type": "whatsapp.sendMessage",
"to": "{{order.customer.phone}}",
"content": {
"text": "Your order is being prepared! Track your delivery here: {{order.tracking_url}}"
}
}
]
}
```
***
## HTTP Schema Generator
### **Auto-Generate API Schemas**
The HTTP Schema Generator automatically creates data schemas from API responses, making integration setup faster and more reliable.
#### **Automatic Schema Detection**
```json
{
"type": "http.schemaGenerator",
"endpoint": "https://api.example.com/users",
"method": "GET",
"sampleSize": 10,
"generateSchema": {
"format": "json-schema",
"includeExamples": true,
"inferTypes": true,
"detectPatterns": true
}
}
```
#### **Generated Schema Output**
```json
{
"schema": {
"type": "object",
"properties": {
"id": {
"type": "integer",
"example": 12345
},
"name": {
"type": "string",
"pattern": "^[A-Za-z\\s]+$",
"example": "John Doe"
},
"email": {
"type": "string",
"format": "email",
"example": "john@example.com"
},
"created_at": {
"type": "string",
"format": "date-time",
"example": "2024-01-15T10:30:00Z"
}
}
},
"validationRules": [
{
"field": "email",
"rule": "required",
"message": "Email is required"
}
]
}
```
### **Schema-Driven Validations**
```json
{
"type": "http.post",
"url": "https://api.external.com/webhook",
"payload": "{{form.data}}",
"schema": "{{generated.schema}}",
"validation": {
"enabled": true,
"strictMode": false,
"onValidationError": [
{
"type": "log.error",
"message": "Schema validation failed: {{validation.errors}}"
},
{
"type": "email.notify",
"to": "admin@company.com",
"subject": "API Integration Error"
}
]
}
}
```
***
## Enhanced Social Media Integrations
### **Advanced Twitter/X Integration**
#### **Smart Content Publishing**
```json
{
"type": "twitter.publishThread",
"content": [
{
"text": "𧡠Thread about {{topic}} (1/{{thread.length}})",
"media": ["{{image.url}}"]
},
{
"text": "{{ai.generated_content.part1}}",
"hashtags": ["{{ai.relevant_hashtags}}"]
},
{
"text": "{{ai.generated_content.part2}}",
"mentions": ["{{ai.relevant_mentions}}"]
}
],
"scheduling": {
"publishAt": "{{ai.optimal_time}}",
"timezone": "{{user.timezone}}"
}
}
```
#### **Engagement Automation**
```json
{
"type": "twitter.engagementFlow",
"triggers": ["mention", "reply", "dm"],
"actions": [
{
"type": "ai.analyzeEngagement",
"input": "{{tweet.text}}",
"sentiment": true,
"intent": true
},
{
"type": "condition.if",
"condition": "{{ai.sentiment}} > 0.7",
"then": [
{
"type": "twitter.like",
"tweetId": "{{tweet.id}}"
},
{
"type": "twitter.reply",
"tweetId": "{{tweet.id}}",
"text": "{{ai.generate_positive_response}}"
}
]
}
]
}
```
### **LinkedIn Business Automation**
#### **Professional Content Distribution**
```json
{
"type": "linkedin.publishPost",
"content": {
"text": "{{ai.professional_content}}",
"media": [
{
"type": "image",
"url": "{{generated.infographic}}",
"alt": "{{ai.alt_text}}"
}
]
},
"targeting": {
"audience": "professional_network",
"industries": ["{{user.industry}}"],
"includeHashtags": true
},
"engagement": {
"trackMetrics": true,
"autoRespond": true,
"escalateThreshold": 10
}
}
```
### **Facebook Pages Integration**
#### **Multi-Format Content Publishing**
```json
{
"type": "facebook.publishContent",
"pageId": "{{facebook.page_id}}",
"content": {
"type": "carousel",
"items": [
{
"image": "{{product.image1}}",
"headline": "{{product.name}}",
"description": "{{ai.product_description}}",
"callToAction": "Shop Now",
"link": "{{product.url}}"
}
]
},
"scheduling": {
"publishTime": "{{ai.optimal_posting_time}}",
"crossPost": ["instagram", "twitter"]
}
}
```
***
## Advanced Error Handling
### **Smart Error Recovery**
#### **Automatic Retry Strategies**
```json
{
"errorHandling": {
"retryPolicy": {
"maxRetries": 3,
"retryDelay": "exponential",
"retryConditions": [
"network_timeout",
"rate_limit_exceeded",
"temporary_server_error"
]
},
"fallbackActions": [
{
"type": "queue.add",
"queue": "failed_requests",
"data": "{{original.payload}}"
},
{
"type": "slack.notify",
"channel": "#system-alerts",
"message": "Automation failed after retries: {{error.message}}"
}
]
}
}
```
#### **Context-Aware Error Classification**
```json
{
"type": "error.classifier",
"error": "{{caught.error}}",
"categories": {
"transient": {
"patterns": ["timeout", "rate.limit", "503", "502"],
"action": "retry_with_backoff"
},
"authentication": {
"patterns": ["401", "403", "invalid.token"],
"action": "refresh_credentials"
},
"permanent": {
"patterns": ["400", "404", "invalid.request"],
"action": "log_and_alert"
}
}
}
```
### **Comprehensive Error Monitoring**
#### **Error Analytics Dashboard**
```json
{
"errorAnalytics": {
"tracking": {
"errorRate": "percentage of failed executions",
"commonFailures": "most frequent error types",
"recoveryTime": "average time to successful retry",
"impactAnalysis": "affected workflows and users"
},
"alerts": [
{
"condition": "error_rate > 5%",
"action": "immediate_alert",
"channels": ["slack", "email", "sms"]
},
{
"condition": "critical_workflow_failure",
"action": "escalation_protocol",
"notify": ["team_lead", "system_admin"]
}
]
}
}
```
***
## AI Agent Integration Enhancements
### **Agent Search & Discovery**
#### **Dynamic Agent Selection**
```json
{
"type": "agent.smartSelect",
"criteria": {
"task": "{{automation.current_task}}",
"domain": "{{workspace.industry}}",
"complexity": "{{task.complexity_score}}"
},
"selection": "best_match",
"fallback": "general_purpose_agent"
}
```
#### **Agent Collaboration Workflows**
```json
{
"type": "agent.collaboration",
"agents": [
{
"role": "analyst",
"task": "analyze_data",
"input": "{{form.responses}}"
},
{
"role": "writer",
"task": "create_summary",
"input": "{{analyst.insights}}"
},
{
"role": "reviewer",
"task": "quality_check",
"input": "{{writer.summary}}"
}
],
"coordination": "sequential",
"quality_gates": true
}
```
### **Conversation Export & Analysis**
#### **Automated Conversation Processing**
```json
{
"type": "agent.exportConversation",
"conversationId": "{{trigger.conversation_id}}",
"format": "markdown",
"processing": [
{
"type": "ai.extractInsights",
"focus": ["key_decisions", "action_items", "unresolved_questions"]
},
{
"type": "document.create",
"title": "Conversation Summary - {{conversation.date}}",
"content": "{{processed.markdown}}",
"project": "meeting_notes"
}
]
}
```
***
## Performance Optimization
### **Batch Processing Optimization**
#### **Intelligent Batching**
```json
{
"batchOptimization": {
"dynamicBatching": {
"enabled": true,
"minBatchSize": 10,
"maxBatchSize": 100,
"timeWindow": "5m",
"optimization": "throughput" // or "latency"
},
"loadBalancing": {
"strategy": "round_robin",
"healthCheck": true,
"failover": "automatic"
}
}
}
```
### **Resource Management**
#### **Memory & Processing Limits**
```json
{
"resourceLimits": {
"memory": {
"max": "512MB",
"alertThreshold": "80%"
},
"processingTime": {
"max": "300s",
"timeout": "hard"
},
"concurrency": {
"max": 10,
"queue": "redis"
}
}
}
```
***
## Build Automations with AI β Available Today
You don't have to assemble flows by hand β Taskade already builds automations from natural language:
* **EVE (Taskade Autonomous Agent)** β describe the outcome you want and EVE drafts the automation: trigger, actions, and connected integrations.
* **Workflow Automation Mode** at [taskade.com/create](https://www.taskade.com/create) β a focused chat mode that generates just the workflow from a single prompt.
* Generated flows are normal automations β open them in the flow editor to adjust triggers, actions, and conditions like any hand-built workflow.
***
**π Ready to leverage these advanced automation capabilities?** Start with loop actions to handle batch processing, then explore WhatsApp Business integration to reach customers where they are.
*For more automation examples and tutorials, check out our* [*Automation Recipes*](/automations/automation/recipes) *and* [*Integration Guide*](/automations/automation/integrations)*.*
# Comprehensive Integrations
Full reference of Taskade automation triggers and actions across 30+ integrations: Slack, Gmail, Google Sheets, HubSpot, GitHub, AI agents, schedules.
This document provides a complete reference of all available integrations, triggers, and actions in Taskade's automation system. For step-by-step guides, see the [Taskade Automation learn center](https://www.taskade.com/learn/automation). Every integration below also has a full setup page in the [Taskade Integrations directory](https://www.taskade.com/integrations).
## Core Taskade Tools
### Taskade
#### Actions
| Action | Description | Properties |
| ---------------------------- | ---------------------------- | ------------------------------------------------------------------ |
| `project.create` | Create Project | `title`, `content`, `defaultView` |
| `task.create` | Add Task | `projectId`, `blockId`, `content`, `position`, `fields`, `dueDate` |
| `task.move` | Move Task Within Project | `projectId`, `nodeId`, `targetBlockId` |
| `task.assign` | Assign Task | `projectId`, `nodeId`, `userId` |
| `markTaskAsCompleted` | Mark Task As Completed | `projectId`, `nodeId` |
| `updateCustomFields` | Update Custom Fields | `projectId`, `nodeId`, `fields` |
| `project.createFromTemplate` | Create Project From Template | `templateId`, `title` |
| `tasks.find` | Find Task(s) | `projectId`, `rowsToReturn`, `noTasksFoundBehavior`, `ruleset` |
#### Triggers
| Trigger | Description | Properties |
| ------------------------------- | ----------------------------------- | -------------------------------------------- |
| `task.completed` | Task Completed (Instant) | `projectId`, `blockId` |
| `task.due` | Task Due (Instant) | `projectId`, `blockId` |
| `task.assigned` | Task Assigned (Instant) | `projectId`, `blockId` |
| `task.added` | Task Added (Instant) | `projectId` |
| `task.custom_attribute_updated` | Task Custom Field Updated (Instant) | `projectId`, `fieldId` |
| `task.flow_triggered` | Task Manual Trigger (Instant) | `projectId` |
| `comment.created` | New Comment (Instant) | `projectId`, `blockId` |
| `duedate.created` | New Due Date (Instant) | `projectId`, `blockId` |
| `project.completed` | Project Completed (Instant) | - |
| `spaceAgent.convo.public.ended` | Agent Public Chat Ended (Instant) | `spaceAgentId`, `conversationExportTimezone` |
| `mailhook` | Mailhook (Instant) | - |
### Taskade AI
#### Actions
| Action | Description | Properties |
| -------------------------------- | ------------------------------ | ------------------------------------------------- |
| `ai.ask` | Ask AI | `prompt`, `input` |
| `ai.generate` | Generate with AI | `prompt`, `input` |
| `ai.respond` | Respond with AI | `prompt`, `input` |
| `ai.categorize` | Categorize with AI | `input`, `output` |
| `ai.prompt` | Prompt AI | `prompt`, `modelName` |
| `agent.ask` | Ask Agent | `agentId`, `input`, `outputType`, `output` |
| `agent.run_command` | Run Agent Command | `agentId`, `commandId`, `input` |
| `agent.add_knowledge` | Add Knowledge To Agent | `agentId`, `knowledgeType`, `title`, `knowledge` |
| `agent.add_knowledge.v2` | Add Knowledge To Agent (v2) | `agentId`, `knowledgeType`, `title`, `knowledge` |
| `agent.add_project_as_knowledge` | Add Project to Agent Knowledge | `agentId`, `projectId` |
| `agentTeam.ask` | Ask Agent Team | `agentTeamId`, `executionMode`, `input`, `output` |
### Schedule
#### Triggers
| Trigger | Description | Properties |
| ------------------ | ----------------------------------------------------------------- | ------------------------------------- |
| `schedule.minutes` | Every X Minutes (Scheduled) β sub-hourly polling, paid-plan gated | `intervalMinutes` (5 / 10 / 15 / 30) |
| `schedule.hourly` | Every Hour (Scheduled) | - |
| `schedule.daily` | Every Day (Scheduled) | `timeOfDay`, `timezone` |
| `schedule.weekly` | Every Week (Scheduled) | `dayOfWeek`, `timeOfDay`, `timezone` |
| `schedule.monthly` | Every Month (Scheduled) | `dayOfMonth`, `timeOfDay`, `timezone` |
### Media
#### Actions
| Action | Description | Properties |
| ------------------------- | ------------------------ | ----------------------------- |
| `web.search` | Search Web | `query` |
| `website.extract` | Scrape Webpage | `websiteUrl`, `errorBehavior` |
| `pdf.convertToText` | Convert File to Text | `pdfUrl` |
| `youtube.transcribeVideo` | Transcribe YouTube Video | `youtubeUrl` |
| `url.addToMedia` | Upload File to Media | `url`, `emptyUrlBehavior` |
| `text.addToMedia` | Upload Text to Media | `text`, `title` |
### Utilities
#### Actions
| Action | Description | Properties |
| --------------------------- | --------------------------- | ---------------------------------------------- |
| `transform.arrayIntoString` | Transform Array Into String | `transformEachItemIntoString`, `joinMechanism` |
## Communication & Collaboration
### Slack
[View the Slack integration β](https://www.taskade.com/integrations/slack)
#### Actions
| Action | Description | Properties |
| ------------------------ | ----------------------- | ---------------------------------- |
| `chat.postMessage` | Send Channel Message | `channel`, `text` |
| `chat.postMessageDirect` | Send Direct Message | `userId`, `text` |
| `create.channel` | Create Channel | `channelName` |
| `find.userByEmail` | Find User by Email | `email` |
| `find.userByHandle` | Find User by Handle | `handle` |
| `add.reactionToMessage` | Add Reaction to Message | `channel`, `timestamp`, `reaction` |
| `pin.message` | Pin Message to Channel | `channel`, `timestamp` |
| `get.channelHistory` | Fetch Channel Messages | `channel`, `oldest`, `latest` |
#### Triggers
| Trigger | Description | Properties |
| -------------------- | ---------------------- | ---------- |
| `new_message` | New Message (Instant) | `channel` |
| `new_channel` | New Channel (Instant) | - |
| `new_mention` | New Mention (Instant) | `channel` |
| `new_reaction_added` | New Reaction (Instant) | `channel` |
### Microsoft Teams
[View the Microsoft Teams integration β](https://www.taskade.com/integrations/microsoft-teams)
#### Actions
| Action | Description | Properties |
| -------------------- | -------------------- | ----------------------------------------------- |
| `createChannel` | Create Channel | `teamId`, `channelName`, `channelDescription` |
| `sendChannelMessage` | Send Channel Message | `teamId`, `channelId`, `contentType`, `content` |
| `sendChatMessage` | Send Chat Message | `chatId`, `contentType`, `content` |
### Discord
[View the Discord integration β](https://www.taskade.com/integrations/discord)
#### Actions
| Action | Description | Properties |
| ---------------- | -------------- | ---------------------- |
| `send_message` | Send Message | `channelId`, `message` |
| `create_channel` | Create Channel | `name` |
| `delete_channel` | Delete Channel | `channelId` |
| `find_channel` | Find Channel | `name` |
| `rename_channel` | Rename Channel | `channelId`, `name` |
#### Triggers
| Trigger | Description | Properties |
| ------------- | ----------------------- | ---------- |
| `new_message` | New Message (Scheduled) | `channel` |
### WhatsApp Business
[View the WhatsApp Business integration β](https://www.taskade.com/integrations/whatsapp)
#### Actions
| Action | Description | Properties |
| --------------------- | --------------------- | ------------------------------------------------------------------- |
| `sendMessage` | Send Message | `phoneNumberId`, `to`, `text` |
| `sendTemplateMessage` | Send Template Message | `phoneNumberId`, `to`, `messageTemplateId`, `messageTemplateFields` |
| `sendMedia` | Send Media | `phoneNumberId`, `to`, `type`, `media`, `caption`, `filename` |
## Email & Communication
### Gmail
[View the Gmail integration β](https://www.taskade.com/integrations/gmail)
#### Actions
| Action | Description | Properties |
| ------------------ | ------------------ | ---------------------------------------------------------------------------------------------------------- |
| `sendEmail` | Send Email | `to`, `cc`, `bcc`, `subject`, `bodyText`, `bodyHtml`, `replyTo`, `from`, `replyToMessageId`, `attachments` |
| `createDraftEmail` | Create Draft Email | `to`, `cc`, `bcc`, `subject`, `bodyText`, `bodyHtml`, `replyTo`, `from`, `replyToMessageId` |
| `findEmail` | Find Email(s) | `emailsToReturn`, `noEmailsFoundBehavior`, `ruleset` |
#### Triggers
| Trigger | Description | Properties |
| -------------------- | --------------------- | ---------- |
| `new_email_received` | New Email (Scheduled) | - |
## Productivity & Data
### Google Sheets
[View the Google Sheets integration β](https://www.taskade.com/integrations/google-sheets)
#### Actions
| Action | Description | Properties |
| --------------------------- | --------------------- | ----------------------------------------------------- |
| `googlesheets.addNewRow` | Insert Row | `spreadsheetId`, `sheetId`, `text` |
| `googlesheets.addNewRowV2` | Insert Row (v2) | `spreadsheetId`, `sheetId`, `fields` |
| `googlesheets.findRows` | Find Row(s) | `spreadsheetId`, `sheetId`, `rowsToReturn`, `ruleset` |
| `googlesheets.deleteRow` | Delete Row | `spreadsheetId`, `sheetId`, `rowId` |
| `googlesheets.updateRow` | Update Row | `spreadsheetId`, `sheetId`, `rowId`, `fields` |
| `googlesheets.findRowByNum` | Get Row by Row Number | `spreadsheetId`, `sheetId`, `rowNumber` |
| `clearRange` | Clear Range | `spreadsheetId`, `sheetId`, `range` |
#### Triggers
| Trigger | Description | Properties |
| --------------- | ------------------- | -------------------------- |
| `new_row_found` | New Row (Scheduled) | `spreadsheetId`, `sheetId` |
### Google Docs
[View the Google Docs integration β](https://www.taskade.com/integrations/google-docs)
#### Actions
| Action | Description | Properties |
| --------------------------- | --------------- | ----------------------------------------------------- |
| `googledocs.appendText` | Append Text | `documentId`, `text` |
| `googledocs.createDocument` | Create Document | `title`, `body` |
| `googledocs.findDocument` | Find Document | `name` |
| `googledocs.findDocuments` | Find Documents | `docsToReturn`, `noDocumentsFoundBehavior`, `ruleset` |
### Google Drive
[View the Google Drive integration β](https://www.taskade.com/integrations/google-drive)
#### Actions
| Action | Description | Properties |
| ----------------------------------- | --------------------------- | ---------------------------------------------------------------- |
| `googledrive.searchFolderOrFile` | Search For Folder/File | `queryTerm`, `operator`, `query`, `type`, `folderId` |
| `googledrive.searchFolderOrFile.v2` | Search For Folder/File (v2) | `drive`, `folderId`, `queryTerm`, `operator`, `query`, `type` |
| `googledrive.moveFile` | Move File | `fileId`, `folderId` |
| `googledrive.addPermission` | Add Permissions | `fileId`, `userEmail`, `permissionName`, `sendNotificationEmail` |
| `googledrive.duplicateFile` | Duplicate File | `fileId`, `name`, `folderId` |
| `googledrive.duplicateFile.v2` | Copy File | `drive`, `folderId`, `fileId`, `name` |
| `googledrive.createNewTextFile` | Create New File | `fileName`, `text`, `fileType`, `folderId` |
| `googledrive.createNewTextFile.v2` | Create New File (v2) | `drive`, `folderId`, `fileName`, `text`, `fileType` |
| `googledrive.uploadFile` | Upload File | `drive`, `folderId`, `file`, `fileName` |
| `googledrive.createNewFolder` | Create New Folder | `folderName`, `folderId` |
| `googledrive.createNewFolder.v2` | Create New Folder (v2) | `drive`, `folderId`, `folderName` |
| `googledrive.sendToTrash` | Trash File | `fileId` |
| `googledrive.deleteFile` | Delete File | `fileId` |
| `googledrive.deletePermission` | Delete Permissions | `fileId`, `userEmail` |
#### Triggers
| Trigger | Description | Properties |
| -------------- | -------------------------- | ------------------------- |
| `new_folder` | New Folder (Scheduled) | `parentFolderId` |
| `new_folderV2` | New Folder (v2, Scheduled) | `drive`, `parentFolderId` |
| `new_file` | New File (Scheduled) | `parentFolderId` |
| `new_fileV2` | New File (v2, Scheduled) | `drive`, `parentFolderId` |
### Google Calendar
[View the Google Calendar integration β](https://www.taskade.com/integrations/google-calendar)
#### Actions
| Action | Description | Properties |
| --------------------------------- | ------------------ | ----------------------------------------------------------------------------------------------- |
| `googlecalendar.deleteEvent` | Delete Event | `calendarId`, `eventId` |
| `googlecalendar.createQuickEvent` | Create Quick Event | `calendarId`, `text`, `sendUpdates` |
| `googlecalendar.createEvent` | Create Event | `calendarId`, `title`, `startDateTime`, `endDateTime`, `location`, `description`, `sendUpdates` |
#### Triggers
| Trigger | Description | Properties |
| ---------------------- | -------------------------------- | ------------ |
| `new_or_updated_event` | New or Updated Event (Scheduled) | `calendarId` |
## CRM & Sales
### HubSpot
[View the HubSpot integration β](https://www.taskade.com/integrations/hubspot)
#### Actions
| Action | Description | Properties |
| -------------------------- | ------------------ | ----------------------------------------------------------------------------------------------------------- |
| `hubspot.createNewContact` | Create New Contact | `firstName`, `lastName`, `email`, `contactOwner`, `jobTitle`, `phoneNumber`, `lifecycleStage`, `leadStatus` |
| `hubspot.createNewDeal` | Create New Deal | `dealname`, `pipelineId`, `dealStageId`, `ownerId`, `dealType`, `amount`, `priority`, `closeDate` |
#### Triggers
| Trigger | Description | Properties |
| --------------------- | ---------------------------- | --------------------------- |
| `new_deal_created` | New Deal (Instant) | - |
| `new_contact_created` | New Contact (Instant) | - |
| `deal_stage_reached` | Deal Stage Reached (Instant) | `pipelineId`, `dealStageId` |
## Development & Project Management
### GitHub
[View the GitHub integration β](https://www.taskade.com/integrations/github)
#### Actions
| Action | Description | Properties |
| ------------------------- | --------------------- | ----------------------------------------- |
| `create_comment_on_issue` | Create Comment | `repository`, `issueNumber`, `comment` |
| `create_issue` | Create Issue | `repository`, `title`, `description` |
| `get_issue_information` | Get Issue Information | `repository`, `issueNumber` |
| `lock_issue` | Lock Issue | `repository`, `issueNumber`, `lockReason` |
| `unlock_issue` | Unlock Issue | `repository`, `issueNumber` |
#### Triggers
| Trigger | Description | Properties |
| ------------------- | --------------------------- | ----------------------------------------- |
| `new_pull_request` | New Pull Request (Instant) | `repository` |
| `new_star` | New Star (Instant) | `repository` |
| `new_issue` | New Issue (Instant) | `repository` |
| `new_push` | New Push (Instant) | `repository` |
| `new_release` | New Release (Instant) | `repository` |
| `new_issue_comment` | New Issue Comment (Instant) | `monitorType`, `organizationOrRepository` |
## Forms & Lead Generation
### Typeform
[View the Typeform integration β](https://www.taskade.com/integrations/typeform)
#### Triggers
| Trigger | Description | Properties |
| ---------------- | ------------------------ | ---------- |
| `new_submission` | New Submission (Instant) | `form` |
### Google Forms
[View the Google Forms integration β](https://www.taskade.com/integrations/google-forms)
#### Triggers
| Trigger | Description | Properties |
| -------------- | ------------------------ | ---------- |
| `new_response` | New Response (Scheduled) | `form_id` |
### Webflow
[View the Webflow integration β](https://www.taskade.com/integrations/webflow)
#### Triggers
| Trigger | Description | Properties |
| --------------------- | ----------------------------- | ------------------ |
| `new_form_submission` | New Form Submission (Instant) | `siteId`, `formId` |
### Calendly
[View the Calendly integration β](https://www.taskade.com/integrations/calendly)
#### Triggers
| Trigger | Description | Properties |
| -------------------------------- | ------------------------------------------- | -------------- |
| `invitee_created` | Any Event Scheduled (Instant) | `scope` |
| `invitee_cancelled` | Event Canceled (Instant) | `scope` |
| `invitee_created_for_event_type` | Event Scheduled for an Event Type (Instant) | `eventTypeUri` |
## Marketing & Email
### MailChimp
[View the MailChimp integration β](https://www.taskade.com/integrations/mailchimp)
#### Actions
| Action | Description | Properties |
| ----------------- | ----------- | ---------------------------------------------------- |
| `addMemberToList` | Add Contact | `firstName`, `lastName`, `email`, `listId`, `status` |
## Social Media & Publishing
### Facebook Pages
[View the Facebook Pages integration β](https://www.taskade.com/integrations/facebook)
#### Actions
| Action | Description | Properties |
| ------------------- | ---------------------- | -------------------------- |
| `create_post` | Create Post | `page`, `message`, `link` |
| `create_photo_post` | Create Post with Image | `page`, `photo`, `caption` |
### X (Twitter)
[View the X (Twitter) integration β](https://www.taskade.com/integrations/twitter)
#### Actions
| Action | Description | Properties |
| -------------- | ------------ | ---------------- |
| `create_reply` | Create Reply | `postId`, `text` |
| `create_post` | Create Post | `text` |
### LinkedIn
[View the LinkedIn integration β](https://www.taskade.com/integrations/linkedin)
#### Actions
| Action | Description | Properties |
| ----------------------- | --------------------- | ------------------------------------------------------------ |
| `create_share_update` | Create Share Update | `text`, `visibility`, `link`, `linkTitle`, `linkDescription` |
| `create_company_update` | Create Company Update | `company`, `text`, `link`, `linkTitle`, `linkDescription` |
### WordPress
[View the WordPress integration β](https://www.taskade.com/integrations/wordpress)
#### Actions
| Action | Description | Properties |
| ------------- | ----------- | -------------------------------------------- |
| `create_post` | Create Post | `type`, `title`, `content`, `slug`, `status` |
### YouTube
[View the YouTube integration β](https://www.taskade.com/integrations/youtube)
#### Triggers
| Trigger | Description | Properties |
| --------------------------- | --------------------- | -------------------- |
| `new_video` | New Video (Scheduled) | `channel_identifier` |
| `multiple_channels_trigger` | New Video (Scheduled) | `channelIdentifiers` |
### Reddit
[View the Reddit integration β](https://www.taskade.com/integrations/reddit)
#### Actions
| Action | Description | Properties |
| ------------- | ----------- | ------------------------------------------------------------------------------ |
| `post-create` | Create Post | `subreddit`, `title`, `kind`, `link`, `text`, `nsfw`, `spoiler`, `sendReplies` |
| `post-get` | Get Post | `postId`, `subreddit` |
### RSS
#### Triggers
| Trigger | Description | Properties |
| ------------------------ | --------------------------------- | ------------ |
| `new_item` | New Item In Feed (Scheduled) | `rssFeedUrl` |
| `multiple_feeds_trigger` | New Item In RSS Feeds (Scheduled) | `feedUrls` |
## SMS & Messaging
### Twilio
[View the Twilio integration β](https://www.taskade.com/integrations/twilio)
#### Actions
| Action | Description | Properties |
| ---------- | ----------- | -------------------- |
| `send_sms` | Send SMS | `from`, `body`, `to` |
## Data Enrichment
### Apollo
[View the Apollo integration β](https://www.taskade.com/integrations/apollo)
#### Actions
| Action | Description | Properties |
| ----------------------- | ----------------------- | ---------------------- |
| `enrichUserInformation` | Enrich User Information | `email`, `linkedinUrl` |
## Technical Integrations
### HTTP
#### Actions
| Action | Description | Properties |
| ------------------ | ----------------- | ----------------------------------------------------------------------------------------------- |
| `http.sendRequest` | Send HTTP Request | `method`, `url`, `headers`, `queryParams`, `bodyType`, `body`, `responseType`, `responseSchema` |
## Control Actions & App Triggers
### App Triggers
* **Forms**: [AI Forms Documentation](https://www.taskade.com/learn/automation/forms-trigger)
* **Webhooks**: [Webhooks Documentation](https://www.taskade.com/learn/automation/webhook-trigger)
* **Agent Triggers**: Built-in agent conversation triggers
### Control Actions
* **Delay**: Wait/Sleep actions for timing control
* **Branch**: [Conditional logic documentation](https://www.taskade.com/learn/automation/branch-action)
* **Loop**: [Iteration control documentation](https://www.taskade.com/learn/automation/loop-action)
* **Filter Data**: [Data filtering documentation](https://www.taskade.com/learn/automation/filter-data)
## Getting Started
To learn more about setting up and using these integrations:
1. [**Getting Started with Automation**](https://www.taskade.com/learn/automation) - Complete beginner's guide
2. [**AI Automation Collection**](https://www.taskade.com/learn/automation) - All automation resources
3. [**Community Forum**](https://www.taskade.com/community) - Get help from the community
4. [**Developer API**](/developers/comprehensive-api-guide/api) - Build custom integrations
***
*This reference is updated regularly with new integrations and features. For the latest updates, visit our* [*Changelog*](/changelog/changelog)*.*
# Workspaces Overview
Organize everything in Taskade workspaces β projects, tasks, members, and billing β the structured-data foundation that powers apps, agents, and automations.
Workspaces are the enhanced foundational containers that organize your teams, projects, and resources in Taskade. Each workspace creates an isolated collaborative environment with dedicated members, customizable settings, granular permission controls, and advanced enterprise capabilities. To see how workspaces fit alongside the full set of [Taskade features](https://www.taskade.com/features), explore the complete product overview.
## What is a Workspace?
**Your Digital Headquarters**
* **Centralized Hub**: Single location for all team collaboration and project management
* **Isolated Environment**: Secure, private space with dedicated members and content
* **Customizable Identity**: Personalize with unique colors, icons, and branding
* **Scalable Structure**: Grows from personal use to enterprise-level organization
**Key Benefits**
* **Enhanced Organized Collaboration**: Keep different teams and projects clearly separated with advanced coordination
* **Enterprise Security Control**: Advanced access control with audit capabilities and enhanced data protection
* **Superior Unified Communication**: Enhanced centralized chat, video calls, and intelligent notifications
* **Advanced Seamless Integration**: Superior AI agents, intelligent automations, and shared templates across workspace
* **Mission-Critical Reliability**: Enterprise-grade stability for business operations
* **Global Performance**: Worldwide synchronization and speed optimization
## Creating a Workspace
### Step-by-Step Setup
1. **Access Creation Menu**
* Click the workspace dropdown in the left sidebar
* Select "Create New Workspace" from the options
2. **Configure Workspace Details**
* **Name**: Choose a clear, descriptive workspace name
* **Description**: Add purpose and scope information
* **Color & Icon**: Select visual identity for easy recognition
* **Privacy Settings**: Choose between private or public workspace
3. **Initial Team Setup**
* Add founding members via email addresses
* Set initial roles and permissions
* Create welcome message for new members
4. **Workspace Structure**
* Plan folder organization for different teams/projects
* Set up initial project templates
* Configure workspace-wide settings
### Workspace Types
| Type | Use Case | Member Limit | Features |
| -------------- | ------------------------ | ------------ | -------------------------------------- |
| **Personal** | Individual productivity | 1 | Basic features, unlimited projects |
| **Team** | Small team collaboration | 10 | Full collaboration, basic automations |
| **Business** | Department/company use | 100 | Advanced features, priority support |
| **Enterprise** | Large organization | Unlimited | Custom integrations, advanced security |
## Workspaces vs. Team Folders (Formerly Teams)
### Understanding the Hierarchy
**Taskade's organizational structure provides flexible ways to group and manage your work:**
```
Organization Level
βββ π’ Workspace (Top-level container)
β βββ π Home Space (Default, cannot be deleted)
β βββ π Team Folder A (Client projects)
β β βββ π Project 1
β β βββ π Project 2
β β βββ π€ AI Agent
β βββ π Team Folder B (Internal projects)
β β βββ π Project 3
β β βββ π Dashboard
β βββ π Team Folder C (Marketing campaigns)
β βββ π Project 4
β βββ π Template Library
```
### Key Differences
| Aspect | Workspace | Team Folder (Team) |
| --------------- | ---------------------------------- | -------------------------------------- |
| **Purpose** | Top-level organizational container | Specialized sub-group within workspace |
| **Creation** | Main organizational unit | Sub-unit for focused collaboration |
| **Members** | Separate member list per workspace | Separate member list per folder |
| **Permissions** | Independent access control | Independent access control |
| **Templates** | Workspace-wide templates | Folder-specific templates |
| **AI Agents** | Workspace-shared agents | Folder-specific agents |
| **Billing** | Associated with subscription | Covered under workspace plan |
| **Deletion** | Cannot delete if it has Home space | Can be deleted individually |
### When to Use Each
#### Choose a Workspace When You Need:
* **Complete Isolation**: Separate companies, clients, or major business units
* **Independent Billing**: Different subscription plans for different areas
* **Full Administrative Control**: Separate admins and billing managers
* **Distinct Branding**: Different visual identity and settings
#### Choose Team Folders When You Need:
* **Client Separation**: Keep client work isolated within shared workspace
* **Team Organization**: Group related projects without separate billing
* **Flexible Collaboration**: Mix internal and external teams
* **Cost Efficiency**: Share premium features across all folders
### Practical Examples
#### Scenario 1: Marketing Agency
```
π’ Marketing Agency Workspace
βββ π Home Space (Agency-wide resources)
βββ π Client A Projects
β βββ Campaign planning
β βββ Content creation
β βββ Analytics reporting
βββ π Client B Projects
β βββ Social media strategy
β βββ Website development
β βββ Brand guidelines
βββ π Internal Operations
βββ Team meetings
βββ Process documentation
βββ Performance reviews
```
#### Scenario 2: Product Development Company
```
π’ Product Company Workspace
βββ π Home Space (Company resources)
βββ π Product Team Alpha
β βββ Feature development
β βββ Bug tracking
β βββ User research
βββ π Product Team Beta
β βββ Mobile app development
β βββ API development
β βββ Testing automation
βββ π Design Team
βββ UI/UX design
βββ Brand assets
βββ Design system
```
### Managing Permissions Across Levels
#### Workspace-Level Permissions
* **Owner**: Full control over workspace, billing, and all folders
* **Admin**: Manage workspace settings and all folder permissions
* **Editor**: Edit content across workspace (subject to folder permissions)
* **Viewer**: Read access to workspace content
#### Folder-Level Permissions
* **Independent Control**: Each folder can have its own permission settings
* **Granular Access**: Invite external collaborators to specific folders only
* **Client Isolation**: Keep client work separate from internal operations
* **Team Autonomy**: Allow team leads to manage their own folder permissions
### Best Practices
#### Workspace Organization
* **Business Units**: Use separate workspaces for different business units
* **Client Work**: Use folders to separate client projects within shared workspaces
* **Security Boundaries**: Use workspaces for strict security separation requirements
* **Cost Optimization**: Use folders to maximize value from workspace subscriptions
#### Permission Management
* **Principle of Least Privilege**: Grant minimum necessary access levels
* **Regular Audits**: Review and update permissions quarterly
* **Documentation**: Maintain clear documentation of permission structures
* **Training**: Ensure team members understand permission implications
#### Migration Strategies
* **Start Simple**: Begin with one workspace and add folders as needed
* **Plan Growth**: Anticipate organizational changes and plan workspace structure
* **Data Migration**: Use export/import tools when restructuring workspaces
* **Communication**: Inform team members of organizational changes
## Team Folders (Teams)
**Organizational Structure**
* **Department Teams**: Marketing, Sales, Engineering, HR
* **Project Teams**: Product launches, campaigns, initiatives
* **Client Teams**: Dedicated spaces for client collaboration
* **Resource Teams**: Templates, assets, knowledge bases
### Folder Management
**Creating Team Folders**
* Right-click in workspace sidebar
* Select "Create New Team/Folder"
* Name and configure folder settings
* Set initial permissions and members
**Folder Features**
* **Nested Organization**: Create sub-folders for detailed organization
* **Bulk Operations**: Move, copy, or delete multiple projects at once
* **Shared Resources**: Templates and assets available to folder members
* **Activity Tracking**: Monitor folder-level activity and changes
### Folder Permissions
{% hint style="success" %}
Team folder permissions provide granular control over who can access and modify content within specific folders, enabling secure collaboration while maintaining data privacy.
{% endhint %}
#### Permission Levels
| Permission Level | Description | Use Case |
| ---------------------- | ------------------------------------------------------------------ | -------------------------------------------- |
| **Invite Only** | Only explicitly invited members can access folder content | Sensitive client work, confidential projects |
| **Everyone Can Edit** | All workspace members can view and edit folder projects | Open collaboration within trusted teams |
| **Everyone Can Check** | All workspace members can view and check tasks (read-only editing) | Stakeholder reviews, progress tracking |
| **Everyone Can View** | All workspace members can view folder content (read-only) | Knowledge sharing, documentation access |
#### Setting Folder Permissions (Desktop)
**During Folder Creation:**
1. Create a new team/folder within a workspace
2. Set folder name, logo, and color theme
3. Choose permission level from dropdown menu
4. Complete folder creation
**Modifying Existing Permissions:**
1. Click the arrow (β½) next to folder name in sidebar
2. Select "Edit" from dropdown menu
3. Choose new permission level
4. Save changes
#### Setting Folder Permissions (Mobile)
**During Folder Creation:**
1. Create new team/folder within workspace
2. Set name and color theme
3. Use "Team Access" dropdown to select permission level
4. Complete folder setup
**Modifying Existing Permissions:**
1. Open folder and tap three dots (β―) in top-right
2. Select "Edit" (βοΈ) option
3. Choose new permission level from dropdown
4. Save changes
#### Permission Inheritance
* **Workspace Level**: Base permissions apply to all folders
* **Folder Level**: Override workspace permissions for specific folders
* **Project Level**: Further restrict access within folders
* **Task Level**: Individual task permissions (where applicable)
#### Best Practices for Folder Permissions
{% hint style="info" %}
Proper permission management balances collaboration with security and prevents accidental data exposure.
{% endhint %}
**Security-First Approach:**
* Default to "Invite Only" for sensitive content
* Regularly audit folder permissions (quarterly reviews)
* Remove access promptly when team members change roles
**Collaboration Optimization:**
* Use "Everyone Can Edit" for active project teams
* Implement "Everyone Can Check" for stakeholder transparency
* Reserve "Everyone Can View" for knowledge repositories
**Administrative Efficiency:**
* Create permission templates for common scenarios
* Document permission policies in workspace guidelines
* Train team members on permission implications
## Member Management
### Inviting Members
**Email Invitations**
* Send personalized invitations with role assignments
* Include welcome message and getting started resources
* Track invitation status and follow up on pending invites
**Invitation Links**
* Generate shareable links for easy team onboarding
* Set expiration dates and usage limits
* Configure default roles for link-based joins
**Bulk Invitations**
* Import member lists from CSV files
* Assign roles and folders in batch operations
* Send coordinated onboarding sequences
### Member Roles & Permissions
**Owner**
* Full workspace control and management
* Can transfer ownership to other members
* Access to billing and subscription settings
* Delete workspace and all contents
**Admin**
* Manage members and permissions
* Create and configure folders/teams
* Access workspace settings (except billing)
* Moderate content and communications
**Member**
* Create and edit projects within assigned folders
* Participate in all collaboration features
* Use AI agents and automations
* Limited administrative capabilities
**Viewer**
* Read-only access to assigned content
* Can comment and participate in discussions
* Cannot create or edit projects
* Ideal for stakeholders and clients
### Advanced Member Management
**Workspace Limits**
* Free: Up to 5 members
* Pro: Up to 10 members
* Business: Up to 100 members
* Enterprise: Unlimited members
**Guest Access**
* Temporary access for external collaborators
* Limited to specific projects or folders
* Automatic expiration dates
* No access to workspace-wide resources
**Self-Join Workspace**
* Administrative capability to join workspaces directly
* Streamlined onboarding for new team members
* Eliminates manual invitation process for administrators
* Maintains security while improving efficiency
## Navigation & Organization
### Workspace Switching
* **Sidebar Dropdown**: Quick access to all your workspaces
* **Keyboard Shortcuts**: Rapid switching between frequently used workspaces
* **Recent Workspaces**: Quick access to recently visited spaces
* **Favorites**: Pin important workspaces for instant access
### Search & Discovery
* **Global Search**: Find content across all workspace projects
* **Scoped Search**: Search within specific folders or teams
* **Filter Options**: Search by content type, author, date, or tags
* **Saved Searches**: Store frequently used search queries
### Activity & Notifications
* **Activity Feed**: Real-time updates on workspace changes
* **Notification Settings**: Customize alerts for different event types
* **Digest Emails**: Weekly summaries of workspace activity
* **Mobile Notifications**: Stay updated on-the-go
### Workspace Navigation Tabs
**Workspace tabs provide quick access to different sections of your workspace**, located at the top of every workspace and folder. These tabs create a structured navigation system for managing your workspace content efficiently.
#### Available Navigation Tabs
**π Projects Tab**
* **Central Hub**: Aggregates all projects within the workspace/folder
* **Quick Access**: Instant access to all your project work
* **Organization**: View projects by creation date, modification, or custom sorting
* **Collaboration**: See active collaborators and recent activity
**π€ AI Agents Tab**
* **Agent Management**: Access all AI agents created within the workspace/folder
* **Customization**: Configure agent personalities, knowledge bases, and behaviors
* **Performance**: Monitor agent usage and effectiveness
* **Sharing**: Share agents across workspace members
**π€ AI Teams Tab**
* **Team Coordination**: Manage AI agent teams for complex workflows
* **Collaboration**: Coordinate multiple AI agents on shared tasks
* **Performance Tracking**: Monitor team effectiveness and output quality
* **Workflow Optimization**: Streamline AI-powered processes
**π Automations Tab**
* **Workflow Management**: Access all automations within the workspace/folder
* **Trigger Configuration**: Set up automated actions and responses
* **Integration Control**: Manage external service connections
* **Performance Monitoring**: Track automation effectiveness and usage
**π Media Tab**
* **File Organization**: Central repository for all uploaded files and documents
* **Search & Filter**: Find files by name, type, upload date, or project association
* **Bulk Operations**: Manage multiple files simultaneously
* **Access Control**: Control who can view, download, or edit files
**β
Tasks Tab**
* **Workspace Overview**: View all tasks within the workspace or folder
* **Task Filtering**: Filter by assigned user and due date status
* **Quick Actions**: Check off tasks directly or navigate to project details
* **Progress Tracking**: Monitor task completion across all projects
#### Tab Navigation Features
**Quick Switching**
* **Tab Clicks**: Instant switching between workspace sections
* **Keyboard Shortcuts**: Rapid navigation with keyboard commands
* **Context Preservation**: Maintain your current view when switching tabs
* **Breadcrumb Navigation**: Clear indication of your current location
**Tab Management**
* **Persistent State**: Tabs remember your last viewed section
* **Responsive Design**: Optimized for desktop, tablet, and mobile devices
* **Customizable Layout**: Adjust tab visibility based on workspace needs
* **Performance Optimized**: Fast loading and smooth transitions between tabs
#### Tab-Specific Workflows
**Project Tab Workflows**
* **Project Creation**: Quick project setup from the projects tab
* **Template Application**: Use workspace templates for consistent project structure
* **Bulk Project Operations**: Apply changes across multiple projects
* **Progress Tracking**: Monitor workspace-wide project completion
**AI Agent Tab Workflows**
* **Agent Creation**: Build new AI agents with workspace context
* **Knowledge Integration**: Upload workspace-specific knowledge bases
* **Testing Environment**: Safe space to test and refine AI agents
* **Deployment Management**: Control agent availability across the workspace
**Automation Tab Workflows**
* **Workflow Design**: Create complex automation sequences
* **Integration Setup**: Connect with external services and APIs
* **Testing Phase**: Validate automation logic before deployment
* **Monitoring Dashboard**: Track automation performance and errors
#### Advanced Tab Features
**Tab Permissions**
* **Role-Based Access**: Different tabs visible based on user permissions
* **Content Filtering**: Show relevant content based on user roles
* **Administrative Controls**: Workspace admins can customize tab visibility
* **Audit Logging**: Track who accesses different workspace sections
**Performance Optimization**
* **Lazy Loading**: Tabs load content on demand for faster initial access
* **Caching Strategy**: Frequently accessed content loads instantly
* **Background Sync**: Updates happen without interrupting user workflow
* **Resource Management**: Efficient memory usage for large workspaces
## Workspace Tasks Tab
**The Tasks Tab provides a comprehensive overview of all tasks within your workspace or folder**, offering powerful filtering and management capabilities to keep your team organized and on track.
{% hint style="success" %}
Unlike the My Tasks dashboard which shows tasks assigned to you across all workspaces, the Workspace Tasks Tab displays all tasks within a specific workspace or folder, giving workspace admins and managers complete visibility into team progress.
{% endhint %}
### Tasks Tab Overview
**Key Features:**
* **Complete Task Visibility**: See all tasks within the workspace/folder hierarchy
* **Advanced Filtering**: Filter by assignee, due date status, and project
* **Quick Task Management**: Complete tasks directly from the tab interface
* **Progress Monitoring**: Track completion rates and identify bottlenecks
* **Navigation Integration**: Click tasks to jump directly to project context
### Task Display and Organization
**How Tasks Appear:**
* **Past Tasks**: Completed and overdue tasks for historical reference
* **Current Tasks**: Active tasks without due dates or with future due dates
* **Upcoming Tasks**: Tasks scheduled for completion in the near future
* **Overdue Tasks**: Tasks past their due date, highlighted for attention
**Task Information Shown:**
* **Task Title**: The main task description
* **Assignee**: Who the task is assigned to (if applicable)
* **Due Date**: When the task should be completed
* **Project Context**: Which project the task belongs to
* **Completion Status**: Whether the task is done or still active
### Filtering and Search Capabilities
**Powerful Filtering Options:**
**By Assignee:**
* Filter tasks by specific team members
* View "My Tasks" within the workspace context
* See unassigned tasks that need assignment
* Monitor team member workloads
**By Due Date:**
* **Past Due**: Tasks that should have been completed already
* **Due Today**: Tasks with today's due date
* **Due This Week**: Tasks due within the next 7 days
* **Due This Month**: Tasks due within the next 30 days
* **No Due Date**: Tasks without specified completion dates
**By Status:**
* **Completed**: Finished tasks for progress tracking
* **In Progress**: Active tasks currently being worked on
* **Not Started**: Tasks that haven't been begun yet
### Task Management Actions
**Direct Task Operations:**
**Complete Tasks:**
* β
**Quick Check-off**: Mark tasks as complete directly from the Tasks Tab
* π **Status Updates**: Change task status without opening the project
* π **Progress Notes**: Add completion notes or updates
**Navigate to Projects:**
* π **Click to Navigate**: Click any task to open its parent project
* π **Context Preservation**: Return to the same location in the project
* π **Deep Linking**: Direct links to specific tasks within projects
**Bulk Operations:**
* **Multi-Select**: Select multiple tasks for batch operations
* **Bulk Assignment**: Assign multiple tasks to team members at once
* **Bulk Due Dates**: Set due dates for multiple tasks simultaneously
* **Bulk Completion**: Mark multiple tasks as complete in one action
### Task Insights and Analytics
**Progress Tracking:**
* **Completion Rates**: Percentage of tasks completed vs. total tasks
* **Team Performance**: Individual and team completion statistics
* **Project Progress**: Progress tracking across different projects
* **Timeline Analysis**: Task completion trends over time
**Productivity Metrics:**
* **Average Completion Time**: How long tasks typically take
* **Overdue Task Analysis**: Identify patterns in missed deadlines
* **Workload Distribution**: Balance of tasks across team members
* **Bottleneck Identification**: Projects or tasks causing delays
### Task Assignment Integration
**Assignment Management:**
* **@Mention Integration**: Assign tasks using @username mentions
* **Keyboard Shortcuts**: Quick assignment with keyboard commands
* **Bulk Assignment Tools**: Assign multiple tasks simultaneously
* **Assignment Notifications**: Automatic notifications to assignees
### Mobile Tasks Tab Experience
**Mobile-Optimized Features:**
* **Touch-Friendly Interface**: Large touch targets for mobile devices
* **Swipe Actions**: Swipe to complete, assign, or navigate to tasks
* **Responsive Filtering**: Mobile-optimized filter controls
* **Offline Capability**: View and manage tasks without internet connection
### Best Practices for Tasks Tab Usage
**Workspace Management:**
* **Regular Reviews**: Use the Tasks Tab for daily/weekly progress reviews
* **Team Stand-ups**: Leverage for quick status updates during meetings
* **Resource Allocation**: Monitor team workloads to prevent burnout
* **Deadline Tracking**: Identify upcoming deadlines and potential conflicts
**Task Organization:**
* **Consistent Assignment**: Ensure all actionable tasks have assignees
* **Realistic Due Dates**: Set achievable deadlines to maintain credibility
* **Clear Task Titles**: Use descriptive titles for easy identification
* **Regular Cleanup**: Archive completed tasks to reduce clutter
**Team Collaboration:**
* **Shared Visibility**: Use the Tasks Tab for team transparency
* **Progress Communication**: Share completion updates with stakeholders
* **Workload Balancing**: Redistribute tasks when team members are overloaded
* **Success Celebration**: Recognize team achievements and milestones
### Troubleshooting Tasks Tab Issues
**Common Issues and Solutions:**
**Tasks Not Appearing:**
* Verify tasks are within the current workspace/folder scope
* Check that tasks have appropriate due dates or assignments
* Ensure proper project permissions and access rights
**Incorrect Filtering:**
* Clear filter selections and reapply
* Check date ranges and assignee selections
* Refresh the page to reset filter state
**Performance Issues:**
* Limit time ranges for large workspaces
* Use specific filters instead of "All Tasks"
* Archive old completed tasks to improve performance
**Sync Problems:**
* Refresh the Tasks Tab to sync with latest changes
* Check internet connectivity for real-time updates
* Verify that changes were properly saved in source projects
### Integration with Other Features
**Workflow Connections:**
* **My Tasks Dashboard**: Personal task view complementing workspace overview
* **Calendar Integration**: Sync due dates with external calendars
* **Automation Triggers**: Use task events to trigger automated workflows
* **AI Agent Integration**: Leverage AI for task prioritization and suggestions
**Export and Reporting:**
* **Task Reports**: Generate workspace task completion reports
* **CSV Export**: Export task data for external analysis
* **API Access**: Programmatic access to task data for custom integrations
* **Dashboard Widgets**: Display task metrics on custom dashboards
## Security & Privacy
### Workspace Privacy Settings
**Private Workspace** (Recommended)
* Invitation-only access
* Content hidden from search engines
* Member list not publicly visible
* Full control over who can join
**Public Workspace**
* Discoverable by other Taskade users
* Public projects visible in search
* Open invitation links
* Suitable for open-source or community projects
### Advanced Security Features
**Two-Factor Authentication**
* Require 2FA for all workspace members
* Enhanced security for sensitive projects
* Integration with authenticator apps
**IP Restrictions** (Enterprise)
* Limit access to specific IP ranges
* Ideal for corporate networks
* Enhanced security compliance
**Audit Logs** (Enterprise)
* Complete activity tracking
* Member action logs
* Compliance reporting
* Data export capabilities
## Workspace Customization
### Visual Identity
* **Custom Colors**: Choose brand colors for workspace theming
* **Icon Selection**: Pick from hundreds of icons or upload custom
* **Logo Upload**: Add company or team logos
* **Theme Settings**: Light/dark mode preferences
### Workspace Settings
* **Default Language**: Set primary language for the workspace
* **Time Zone**: Configure default time zone for scheduling
* **Date Format**: Customize date display preferences
* **Notification Defaults**: Set workspace-wide notification preferences
### Integration Configuration
* **Connected Apps**: Manage third-party integrations
* **API Access**: Configure developer access and tokens
* **Webhook Settings**: Set up external system notifications
* **Enterprise Security**: Advanced authentication and access controls
***
## **Enterprise Security & Compliance**
### **Single Sign-On (SSO) Integration**
Taskade supports enterprise-grade authentication through multiple identity providers:
| **Provider** | **Protocol** | **Features** | **Best For** |
| ---------------------- | ------------ | ------------------------------------- | -------------------------- |
| **Google Workspace** | SAML 2.0 | Directory sync, MFA support | Google-first organizations |
| **Microsoft Azure AD** | SAML 2.0 | Conditional access, device compliance | Microsoft 365 environments |
| **Okta** | SAML 2.0 | Advanced identity management | Multi-app enterprises |
| **Generic SAML** | SAML 2.0 | Custom identity providers | Specialized security needs |
### **SSO Setup Process**
**1. Identity Provider Configuration**
* Configure SAML application in your IdP
* Set ACS URL: `https://www.taskade.com/auth/saml/callback`
* Configure attribute mapping for email and name
* Download IdP certificate and metadata
**2. Taskade Configuration**
* Navigate to Workspace Settings β Security
* Upload IdP certificate and configure metadata
* Test SSO connection with test user
* Enable for all workspace members
**3. User Provisioning**
* **Automatic**: Users created on first SSO login
* **Manual**: Pre-create users with email matching
* **SCIM**: Automated user lifecycle management (Enterprise)
### **SCIM User Provisioning**
Automate user lifecycle management with SCIM 2.0 support:
| **Capability** | **Description** | **Business Benefit** |
| --------------------- | ----------------------------------- | -------------------------------------- |
| **Auto-Provisioning** | Create users automatically from IdP | Instant workspace access for new hires |
| **De-provisioning** | Remove access when users leave | Immediate security compliance |
| **Profile Sync** | Keep user information updated | Accurate directory information |
| **Group Management** | Sync team memberships | Consistent access across systems |
### **Advanced Access Controls**
| **Feature** | **Description** | **Use Case** |
| ---------------------- | ------------------------------------- | ------------------------------------ |
| **IP Restrictions** | Limit access to specific IP ranges | Office-only access policies |
| **Device Management** | Control access by device type/status | BYOD security compliance |
| **Session Management** | Configure session timeouts and limits | Enhanced security for sensitive data |
| **MFA Enforcement** | Require multi-factor authentication | Additional security layer |
### **Audit & Compliance**
| **Audit Type** | **Information Tracked** | **Retention** |
| -------------------------- | ----------------------------------------------------- | --------------------- |
| **User Activity** | Login/logout, project access, data changes | 1 year (configurable) |
| **Administrative Actions** | Permission changes, user management, settings | 3 years (compliance) |
| **Data Access** | File downloads, sharing actions, exports | 90 days (privacy) |
| **Security Events** | Failed logins, suspicious activity, policy violations | 5 years (security) |
### **Data Protection & Privacy**
**Encryption Standards**
* **In Transit**: TLS 1.3 for all communications
* **At Rest**: AES-256 encryption for stored data
* **Key Management**: Hardware security modules (HSMs)
* **Certificate Management**: Automated renewal and rotation
**Privacy Controls**
* **Data Residency**: Choose data storage regions
* **Data Retention**: Configurable retention policies
* **Right to Deletion**: GDPR-compliant data removal
* **Data Portability**: Complete data export capabilities
**Compliance Certifications**
* **SOC 2 Type II**: Security and availability controls
* **GDPR**: European data protection compliance
* **CCPA**: California privacy rights compliance
* **HIPAA**: Healthcare data protection (Enterprise)
### **Enterprise Administration**
**Centralized Management**
* **Multi-Workspace Control**: Manage multiple workspaces from single admin panel
* **Policy Templates**: Standardized security policies across workspaces
* **Bulk Operations**: Mass user management and permission updates
* **Automated Reporting**: Scheduled compliance and usage reports
**Advanced Monitoring**
* **Real-time Alerts**: Security events and policy violations
* **Usage Analytics**: Detailed workspace and user activity metrics
* **Performance Monitoring**: System health and response times
* **Custom Dashboards**: Executive and administrative reporting views
## Best Practices
### Organization Strategy
* **Clear Naming**: Use descriptive, consistent naming conventions
* **Logical Structure**: Organize folders by function, not just projects
* **Regular Cleanup**: Archive completed projects and remove inactive members
* **Documentation**: Maintain workspace guidelines and onboarding docs
### Security Best Practices
* **Regular Audits**: Review member permissions quarterly
* **Principle of Least Privilege**: Grant minimum necessary access
* **Guest Management**: Regularly review and expire guest access
* **Backup Strategy**: Regular exports of critical workspace data
### Collaboration Optimization
* **Onboarding Process**: Standardized welcome and training for new members
* **Communication Guidelines**: Establish norms for chat, comments, and meetings
* **Template Library**: Maintain shared templates for common project types
* **Feedback Loops**: Regular retrospectives and improvement sessions
## Mobile Workspace Management
### Mobile Features
* **Full Workspace Access**: Complete workspace functionality on mobile
* **Offline Sync**: Work offline with automatic sync when connected
* **Push Notifications**: Real-time alerts for important workspace activity
* **Quick Actions**: Rapid project creation and task management
### Mobile-Specific Tools
* **Voice Commands**: Create tasks and projects using voice input
* **Photo Integration**: Capture and share photos directly to projects
* **Location Services**: Location-based reminders and check-ins
* **Biometric Security**: Fingerprint and face ID for secure access
## Workspace Organization & Management
### Setting Default Workspace
**What is a Default Workspace?** Your default workspace appears first in the sidebar and is the initial landing page when you open Taskade. This streamlines your workflow by prioritizing your most frequently used workspace.
**How to Set Default Workspace:**
1. **Locate Workspace Order**: The top workspace in your sidebar becomes your default
2. **Reorder Workspaces**: Simply drag and drop workspaces to change their position
3. **Automatic Saving**: Changes sync instantly across all your devices
**Benefits:**
* **Faster Access**: Quick entry to your primary workspace
* **Workflow Efficiency**: Start your day in the right context
* **Personalization**: Customize your Taskade experience to match your work patterns
### Reordering Workspaces
**Drag & Drop Reorganization:**
1. **Access Sidebar**: Open Taskade and view your workspace list
2. **Select Workspace**: Click and hold the workspace icon you want to move
3. **Drag to Position**: Drag the workspace up or down the list
4. **Drop to Confirm**: Release to set the new position
**Visual Feedback:**
* **Highlighting**: Selected workspace shows visual indication
* **Position Preview**: See where the workspace will land during drag
* **Smooth Animation**: Fluid movement for better user experience
**Advanced Organization Tips:**
* **Priority Order**: Place most-used workspaces at the top
* **Project Phases**: Group workspaces by current project phases
* **Team Structure**: Organize by team or department importance
* **Personal vs Work**: Separate personal and professional workspaces strategically
***
**Related Features:**
* [Collaboration](/workspaces/workspaces/collaboration) - Team communication and coordination
* [AI Agents](/ai-features/ai-features/ai-agents-getting-started) - Workspace-wide AI assistance
* [Project Views](/workspaces/workspaces/project-views) - Organizing and visualizing work
* [Mobile Optimization](/workspaces/workspaces/mobile-optimization) - Mobile workspace management
# Projects & Databases
Build Taskade database projects: custom fields, relationships, and 9 views. See how Taskade Genesis auto-generates schemas that power apps and agents.
***
## Table of Contents
* [Overview](#overview)
* [What Are Database Projects?](#what-are-database-projects)
* [Taskade Genesis-Generated Databases](#taskade-genesis-generated-databases)
* [9 Project Views](#id-9-project-views)
* [Manual Database Creation](#manual-database-creation)
* [Importing Data](#importing-data)
* [Automated App Workflows](#automated-app-workflows)
* [AI Agents in App Databases](#ai-agents-in-app-databases)
* [How Memory Powers Your Entire Workspace](#how-memory-powers-your-entire-workspace)
* [Best Practices](#best-practices)
* [What's Next](#whats-next)
***
## Overview
Projects & Databases are the **Memory pillar** of your Workspace DNA β one of three pillars (Memory/Projects, Intelligence/Agents, Execution/Automations) forming the [Tree of Life architecture](/taskade-genesis/genesis/how-genesis-works#the-tree-of-life-architecture). They store, structure, and persist the information that powers every Genesis app, AI agent, and automation flow.
> **DNA Impact:** Each project adds **+2 points** to your [Intelligence Score](/taskade-genesis/genesis/how-genesis-works#workspace-intelligence-score) (up to 10 projects = 20 points max from the Memory pillar).
***
## What Are Database Projects?
Database projects are structured data containers that serve as your app's persistent memory. Unlike regular documents, they have:
| Feature | Description |
| --------------------- | -------------------------------------------------------------------------------------------------------------------- |
| **Custom fields** | Define field types: text, number, currency, rating, date, select, multi-select, checkbox, URL, person |
| **Relationships** | Link records across databases (e.g., customers β orders) |
| **Views** | List, board, table, calendar, and more |
| **Filters & sorts** | Find and organize data dynamically |
| **Permissions** | Control who can view and edit data |
| **API access** | Programmatic access for integrations (Business+) β see the [REST API reference](/developers/comprehensive-api-guide) |
| **Real-time sync** | Changes reflect instantly across all connected apps and agents |
| **Revision tracking** | Every change tracked via operational transform (OT) |
***
## Taskade Genesis-Generated Databases
When Genesis builds an app, it **automatically creates the database structures** your app needs:
| App Type | Databases Created | Fields Generated |
| --------------------- | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| **Customer Feedback** | Feedback entries, Contacts | Rating (number), Comment (text), Category (select), Status (select), Photo (media), Contact info (text), Timestamp (date) |
| **Booking System** | Appointments, Clients, Services | Date/time (date), Client (relation), Service (select), Status (select), Price (number), Notes (text) |
| **CRM** | Leads, Deals, Contacts | Name (text), Email (text), Stage (select), Value (number), Source (select), Last contact (date), Score (number) |
| **Inventory** | Products, Suppliers, Orders | SKU (text), Name (text), Quantity (number), Reorder level (number), Supplier (relation), Price (number) |
| **Help Desk** | Tickets, Agents, Categories | Title (text), Description (text), Priority (select), Status (select), Assignee (relation), SLA (date) |
| **Course Platform** | Courses, Students, Enrollments | Title (text), Content (text), Progress (number), Grade (number), Status (select), Certificate (checkbox) |
> **Fully automatic:** You don't need to define these structures. Genesis infers them from your prompt and creates optimized schemas.
***
## 9 Project Views
Every project database supports 9 different views β switch between them without changing your data:
| View | Description | Best For |
| ---------------- | -------------------------------------------------------------------------------------- | --------------------------------------------- |
| **Table** | Structured spreadsheet-like format with filtering, sorting, grouping, and aggregations | Data management, CRM, inventory |
| **List** | Vertical list/to-do format with checkboxes and hierarchy | Task management, checklists, notes |
| **Board** | Kanban columns for workflow stages (drag-and-drop) | Pipeline management, sprints, status tracking |
| **Calendar** | Events on calendar grid for deadline tracking | Scheduling, appointments, content calendars |
| **Gantt** | Timeline with task duration, dependencies, and progress tracking | Project planning, timelines, milestones |
| **Mindmap** | Connected nodes radiating from center for visualization | Brainstorming, concept mapping, planning |
| **Orgchart** | Hierarchical organizational structure | Team structure, process hierarchy |
| **Action Sheet** | Compact action-oriented format | Quick task management |
| **Docs (Beta)** | Continuous rich-text document editing | Specs, knowledge bases, long-form writing |
> **Tip:** In Genesis apps, you can specify which view to use: "Display the customer database as a kanban board with columns for Lead, Qualified, Proposal, Won."
***
## Manual Database Creation
You can also create databases manually:
### Step-by-Step Tutorial
| Step | Action |
| ---- | ------------------------------------------------------------- |
| 1 | Create a new project in your workspace |
| 2 | Switch to **Table** view for structured data |
| 3 | Click "+" on column headers to add custom fields |
| 4 | Define field types and options (see table below) |
| 5 | Add records manually, via import, or via automations |
| 6 | Switch between views (Board, Calendar, Gantt, etc.) as needed |
| 7 | Set permissions (who can view, edit) |
### Available Field Types
| Field Type | Use Case | Example | Formatting Options |
| ----------------- | --------------------------------- | ---------------------------------------- | ---------------------------------------------------------------------------------- |
| **Text (String)** | Names, descriptions, notes | Customer name, product description | Plain text |
| **Number** | Quantities, scores, counts | Stock level, quantity, score | Decimal, percent (%) |
| **Currency** | Pricing, invoices, budgets | Product price, invoice total, budget cap | Pre-formatted as USD; numeric field with currency symbol and decimal precision |
| **DateTime** | Deadlines, timestamps, schedules | Due date, appointment time | Date only, date + time; Table view footers can aggregate Earliest / Latest / Range |
| **Rating** | Feedback scores, priority ranking | Review stars, lead quality | Configurable star rating per row |
| **Select** | Single-choice categories | Status, priority, category | Color-coded options |
| **Multi-select** | Multiple tags/categories | Skills, interests, tags | Color-coded options |
| **Checkbox** | Boolean yes/no states | Completed, approved, active | Toggle |
| **URL** | Web links | Website, profile link | Clickable link |
| **Person** | Team member assignment | Assignee, reviewer, owner | Workspace member picker |
| **Relationship** | Link records across projects | Customer β Orders, Lead β Deals | Cross-project record picker |
### Task Addons (Beyond Custom Fields)
| Addon | What It Does | Where It Appears |
| ----------------- | --------------------------------------- | ---------------------------------- |
| **Due dates** | Start and end dates with optional times | All views |
| **Assignees** | Assign tasks to team members | All views |
| **Labels/Tags** | Color-coded tags for categorization | All views |
| **Timers** | Track time spent on tasks | List, Table views |
| **Custom fields** | Any field type from the table above | Table view (configurable per view) |
| **Comments** | Thread discussions on any task | Task detail view |
### Task Content Types
| Format | Style | Use For |
| ---------------- | ----------------- | ---------------------- |
| **h1** | Heading 1 | Section titles |
| **h2** | Heading 2 | Sub-sections |
| **text** | Paragraph | Descriptions, notes |
| **checkbox** | Checkable task | To-do items |
| **circle-check** | Circle checkbox | Alternative task style |
| **bullet** | Bullet list | Unordered lists |
| **number** | Numbered list | Ordered steps |
| **alpha** | Alphabetical list | Lettered items |
***
## Importing Data
Bring existing data into your projects:
| Method | Format | Best For |
| ------------------ | ------------------------ | -------------------------------------------------------- |
| **File upload** | CSV, XLSX | Bulk data import from spreadsheets |
| **Copy-paste** | Structured text | Quick data entry |
| **API import** | JSON via API (Business+) | Programmatic data migration |
| **Automation** | From connected tools | Ongoing data sync from Google Sheets, CRM, etc. |
| **Genesis prompt** | Natural language | "Import the customer data from the uploaded spreadsheet" |
***
## Automated App Workflows
Genesis databases work as live data stores within automation flows:
### Booking System Example
| Trigger | Action | Database Impact |
| --------------------------- | ---------------------------- | ------------------------------------------- |
| New booking form submitted | Create appointment record | Appointments database: new row added |
| Payment confirmed | Update status to "Confirmed" | Appointments database: status field updated |
| 24 hours before appointment | Send reminder notification | Read from Appointments database |
| Appointment completed | Request feedback | Create entry in Feedback database |
### CRM Example
| Trigger | Action | Database Impact |
| -------------------------- | ----------------------------- | ---------------------------------------------------- |
| Lead form submitted | Create lead record with score | Leads database: new row with AI-scored qualification |
| Lead unresponsive 48 hours | Send follow-up email | Read from Leads database, update Last Contact date |
| Lead qualified | Move to deals pipeline | Create record in Deals database, link to Lead |
| Deal closed | Update status, notify team | Deals database: status to "Won", Slack notification |
### Inventory Example
| Trigger | Action | Database Impact |
| --------------------- | ----------------------------------- | ------------------------------------------ |
| Stock below threshold | AI agent calculates optimal reorder | Products database: read stock level |
| Reorder approved | Email supplier, create PO | Orders database: new purchase order record |
| Shipment received | Update stock levels | Products database: quantity updated |
| Sales data captured | Analyze patterns | Products database: sales history enriched |
***
## AI Agents in App Databases
AI agents interact with your databases as living knowledge:
| Integration | How It Works | Example |
| -------------------- | ------------------------------------- | ----------------------------------------------------- |
| **Knowledge source** | Connect project as agent knowledge | Support agent trained on ticket history database |
| **Data entry** | Agent creates records via tools | Agent logs customer interactions to CRM database |
| **Data retrieval** | Agent queries databases for answers | Agent looks up order status from Orders database |
| **Analysis** | Agent identifies patterns in data | Agent analyzes feedback trends from Feedback database |
| **Updates** | Agent modifies records based on logic | Agent escalates tickets by updating priority field |
> **Dynamic knowledge:** When agents are connected to project databases, they always have the latest data β no re-training needed. See [Agent Knowledge & Memory](/ai-features/ai-features/agent-knowledge#dynamic-knowledge-projects).
***
## How Memory Powers Your Entire Workspace
| Memory Source | What It Feeds | Result |
| ----------------------- | --------------------------------- | ------------------------------------------ |
| **Project databases** | Genesis app UI, forms, dashboards | Apps display and interact with real data |
| **Project databases** | AI agent knowledge | Agents answer questions with current data |
| **Project databases** | Automation triggers | Workflows fire based on data changes |
| **Automation results** | Project databases (writes back) | New data from automations enriches memory |
| **Agent conversations** | Project databases (logs) | Interaction data becomes new memory |
| **User interactions** | Project databases (captures) | App usage generates valuable business data |
> **The feedback loop:** Every interaction with your Genesis app writes data back to projects, which agents read, which improves automations, which captures more data. This is the [self-reinforcing feedback loop](/taskade-genesis/genesis/how-genesis-works#the-self-reinforcing-feedback-loop) in action.
***
## Best Practices
| Practice | Why | How |
| ---------------------------- | ------------------------------------- | ---------------------------------------------------------- |
| **Keep data focused** | Prevents bloated, confusing databases | One database per entity type (Customers, Orders, Products) |
| **Plan for growth** | Databases scale with your business | Define fields that accommodate future data |
| **Control access** | Protects sensitive information | Set permissions per project (who can view, edit) |
| **Use relationships** | Connects data meaningfully | Link Customers β Orders β Products via relation fields |
| **Name fields clearly** | Makes agent queries more accurate | "Customer Email" not "Field 3" |
| **Clean data regularly** | Prevents stale knowledge | Archive old records, update outdated entries |
| **Connect to agents** | Maximizes DNA value | Every important database should be agent knowledge |
| **Use automations to write** | Keeps data current automatically | Form submissions β auto-create records |
***
## What's Next
| Guide | What You'll Learn |
| -------------------------------------------------------------------- | ------------------------------------------------- |
| [Automations: The Execution Pillar](/automations/automation) | Build workflows that read/write to your databases |
| [Agent Knowledge & Memory](/ai-features/ai-features/agent-knowledge) | Connect databases as agent knowledge |
| [Adding Genesis Context](/taskade-genesis/genesis/adding-context) | Import data files to kickstart your databases |
| [How Genesis Works](/taskade-genesis/genesis/how-genesis-works) | Understand how Memory fits in the Tree of Life |
# Teams
Organize Taskade for teams with workspace, folder, and function structures, a 5-role RBAC permission system, and AI-powered team features.
***
## Table of Contents
* [Overview](#overview)
* [Key Terminology](#key-terminology)
* [Workspace Organization Methods](#workspace-organization-methods)
* [Method 1: Workspace per Department](#method-1-workspace-per-department)
* [Method 2: One Workspace, Folders per Department](#method-2-one-workspace-folders-per-department)
* [Method 3: One Workspace, Folders per Function](#method-3-one-workspace-folders-per-function)
* [Permission System](#permission-system)
* [Step-by-Step Setup](#step-by-step-setup)
* [AI-Powered Team Features](#ai-powered-team-features)
* [What's Next](#whats-next)
***
## Overview
Taskade is designed for teams of any size. This guide covers the different ways to organize your workspace β from small teams to large enterprises β and how AI-powered features amplify team productivity.
> **Taskade Genesis hint:** Teams that use Genesis apps can give every department custom internal tools, dashboards, and client portals β all connected to the same Workspace DNA.
***
## Key Terminology
| Term | Definition | Analogy |
| ------------- | ------------------------------------------------------------------------ | ------------------------------ |
| **Workspace** | Top-level container for folders, projects, and templates | Like a company or organization |
| **Folder** | Container for projects nested within a workspace | Like a department or team |
| **Project** | Digital canvas for tasks, notes, and collaboration | Like a document or whiteboard |
| **Space** | Collaborative workspace with sub-spaces (max 2 levels: Root β Sub-space) | Like a team room |
***
## Workspace Organization Methods
### Method 1: Workspace per Department
Create a separate workspace for each department with function-specific folders.
| Setup | Detail |
| -------------------- | ---------------------------------------------------------- |
| **Structure** | One workspace per department |
| **Folders** | Function-specific folders within each workspace |
| **Invitations** | Team members in their respective workspaces |
| **Cross-department** | Invite members from other departments to specific projects |
**Example:**
| Marketing Workspace | HR Workspace | Accounting Workspace | Engineering Workspace |
| ------------------- | ------------------- | -------------------- | --------------------- |
| Home (Default) | Home (Default) | Home (Default) | Home (Default) |
| Meetings | Performance Reviews | Accounts Payable | Sprint Planning |
| Campaigns | Hiring Pipeline | Budget Tracking | Code Reviews |
| Social Media | Training | Invoicing | QA & Testing |
| Analytics | Policies | Reporting | Infrastructure |
**Ideal for:**
* Medium to large organizations
* Specialized, independent teams
* Functional/divisional structures
* Teams with minimal cross-department overlap
### Method 2: One Workspace, Folders per Department
A single workspace with department-level folders.
| Setup | Detail |
| -------------------- | ------------------------------------------------------ |
| **Structure** | One workspace for entire team |
| **Folders** | One folder per department |
| **Invitations** | Each member added to their department folder |
| **Cross-department** | Easy collaboration β everyone is in the same workspace |
**Ideal for:**
* Small to medium teams (under 50 people)
* Teams with frequent cross-department collaboration
* Startups and growing companies
### Method 3: One Workspace, Folders per Function
A single workspace with function-specific folders (not department-based).
| Setup | Detail |
| -------------------- | -------------------------------------------------------------- |
| **Structure** | One workspace for entire team |
| **Folders** | One folder per function (Meetings, Operations, Planning, etc.) |
| **Permissions** | Function-level access control |
| **Cross-functional** | All departments contribute to shared function folders |
**Ideal for:**
* Cross-functional teams
* Matrix organizations
* Project-based structures
***
## Permission System
Taskade uses a **5-role, 7-tier RBAC** permission system:
| Role | Capabilities |
| ---------------- | -------------------------------------------------------------- |
| **Owner** | Full control β manage workspace, billing, members, all content |
| **Admin** | Manage members, projects, folders, agents, automations |
| **Collaborator** | Create and edit projects, use agents, run automations |
| **Participant** | Edit assigned tasks, comment, chat |
| **Viewer** | Read-only access to shared content |
> Permission inheritance flows: Organization β Workspace β Folder β Project. Members inherit permissions from higher levels unless overridden.
***
## Step-by-Step Setup
### Create a Workspace
| Step | Action |
| ---- | ----------------------------------------------------------- |
| 1 | In your dashboard, click the **+** icon on the left sidebar |
| 2 | Enter the workspace name |
| 3 | *(Optional)* Choose a workspace logo |
| 4 | *(Optional)* Invite team members |
### Create Folders
| Step | Action |
| ---- | -------------------------------------------------------- |
| 1 | Open your workspace |
| 2 | Click **New folder** under Home |
| 3 | Enter the folder name |
| 4 | *(Optional)* Choose a folder logo |
| 5 | *(Optional)* Share the folder with specific team members |
### Create Projects
| Step | Action |
| ---- | --------------------------------------------- |
| 1 | Open a folder |
| 2 | Click **+ Create new** (top-right corner) |
| 3 | Type the project title |
| 4 | *(Optional)* Share the project to collaborate |
***
## AI-Powered Team Features
| Feature | How It Helps Teams | Learn More |
| --------------------------- | ---------------------------------------------------- | ----------------------------------------------------------- |
| **Taskade Autopilot** | Generate entire team workspaces from a single prompt | [Taskade Autopilot](/ai-features/ai-features/autopilot) |
| **AI Agents** | Create specialist agents for each department | [Custom AI Agents](https://www.taskade.com/learn/genesis) |
| **Multi-Agent Teams** | Teams of agents that collaborate (Business+) | [Multi-Agents](https://www.taskade.com/learn/genesis) |
| **Automation Workflows** | Automate cross-department processes | [Automation Triggers](/automations/automation) |
| **Genesis Apps** | Build internal tools and dashboards for teams | [Taskade Genesis](https://www.taskade.com/learn/genesis) |
| **Shared Agent Chats** | AI + human conversations together | [Custom AI Agents](https://www.taskade.com/learn/genesis) |
| **Version History** | Track all changes across team projects | [Version History](/taskade-genesis/genesis/version-history) |
| **Real-time Collaboration** | Multiple users editing simultaneously (OT-based) | Built-in |
***
## What's Next
| Guide | What You'll Learn |
| ----------------------------------------------------------------- | ------------------------------ |
| [Taskade Autopilot](/ai-features/ai-features/autopilot) | Auto-generate team workspaces |
| [Editing & Formatting](/workspaces/workspaces/editing-formatting) | Format and style team projects |
| [Embed Taskade](/workspaces/workspaces/embed) | Share projects on your website |
| [Version History](/taskade-genesis/genesis/version-history) | Track team changes |
# Collaboration
Collaborate in real time on Taskade with live co-editing, team chat, comments, video calls, presence, and async tools plus AI summaries and version history.
Taskade enables seamless real-time and asynchronous collaboration across teams. Use chat, video, presence, and comments to stay aligned while work happens in projects, agents, and automations.
## Real-Time Collaboration
**Live Co-Editing**
* Multiple people can edit the same project simultaneously
* See profile pictures next to tasks being edited by teammates
* Real-time typing indicators show who's working where
* Conflict-free editing ensures no work is lost
* Instant sync across web, desktop, and mobile devices
**Visual Collaboration Indicators**
* **Cursor Presence**: See exactly where team members are working
* **Typing Indicators**: Real-time feedback on active editing
* **Profile Pictures**: Quick identification of who's editing what
**Cross-Platform Sync**
* Changes appear instantly across all devices
* Seamless handoff between desktop, web, and mobile
* Offline changes sync when reconnected
* Version consistency maintained automatically
## Chat and Messaging
### Asynchronous vs Real-Time Collaboration
Taskade supports both asynchronous and synchronous (real-time) collaboration, allowing teams to choose the best communication method for their workflow. Asynchronous collaboration enables flexible communication without requiring everyone to be online simultaneously.
**When to Use Asynchronous Collaboration:**
* **Flexible Work Schedules**: Team members in different time zones or with varying work hours
* **Deep Work Focus**: Allowing uninterrupted work periods without constant interruptions
* **Complex Decision Making**: Time to think through and research before responding
* **Documentation**: Creating permanent records of discussions and decisions
### Team Chat
**Send messages and keep your team in the loop without the pressure to stay online 24/7:**
{% stepper %}
{% step %}
#### Open Project Chat
Open any project and click the **π¬ chat balloon icon** in the top-right corner.
{% endstep %}
{% step %}
#### Choose Team Chat
Select **π¬ Team Chat** using the dropdown at the top of the chat box.
{% endstep %}
{% step %}
#### Send Your Message
Type your message and press **Enter** or click the **arrow button** to send it.
{% endstep %}
{% endstepper %}
**Team Chat Benefits:**
* **Asynchronous Communication**: Send messages without requiring immediate responses
* **Project Context**: All chat is tied to specific projects for better organization
* **File Sharing**: Share documents, images, and links directly in chat
* **Mention System**: Use @mentions to notify specific team members
* **Message History**: Complete chat history maintained for future reference
### Private Conversations
**Create private projects for 1-on-1 chats and confidential discussions:**
{% stepper %}
{% step %}
#### Create Private Project
Create a new project in your private Workspace or Folder (not shared).
{% endstep %}
{% step %}
#### Invite Participant
Click **Share** (top-right) β **Invite to project** β **Email** tab β Enter team member details.
{% endstep %}
{% step %}
#### Start Chatting
Begin your private conversation in the project's chat panel.
{% endstep %}
{% endstepper %}
**Privacy Features:**
* **Access Control**: Only invited members can view and participate
* **Secure Communication**: Encrypted message transmission
* **Workspace Boundaries**: Conversations stay within designated workspace limits
* **Link Sharing**: Optionally disable link sharing for maximum privacy
### Project Comments
**Leave contextual feedback and discuss tasks within projects:**
**Comment Types:**
* **Task Comments**: Add notes directly to specific tasks for detailed feedback
* **Project Comments**: General discussion about project progress and decisions
* **Threaded Conversations**: Reply to comments to create focused discussions
**Adding Comments:**
1. **Hover over any task** or click on it to open the task panel
2. **Click the comment icon** (π¬) in the task options
3. **Type your comment** and press Enter to post
4. **Use @mentions** to notify specific team members
5. **Attach files** or links to provide additional context
**Comment Features:**
* **Real-time Updates**: See new comments instantly across all devices
* **Mention Notifications**: Get notified when you're mentioned in comments
* **Threaded Replies**: Keep conversations organized with reply chains
* **File Attachments**: Share documents, images, or links with comments
* **Markdown Support**: Format comments with bold, italic, lists, and links
**Comment Best Practices:**
* **Be Specific**: Reference particular tasks or sections when commenting
* **Use Mentions**: Tag relevant team members to ensure visibility
* **Keep it Actionable**: Include clear next steps or decisions in comments
* **Attach Evidence**: Include screenshots, documents, or links when relevant
### Screencast Comments
**Record and share screen recordings directly in project comments:**
**Recording Process:**
1. **Open a comment** on any task
2. **Click the screencast icon** (πΉ) in the comment toolbar
3. **Select recording area**: Choose full screen, application window, or specific region
4. **Start recording** and demonstrate the issue or process
5. **Stop recording** when finished - video automatically attaches to comment
**Screencast Features:**
* **No External Tools**: Record directly within Taskade without third-party software
* **Multiple Formats**: Record full screen, specific windows, or selected areas
* **Instant Sharing**: Video uploads automatically and is immediately viewable
* **Team Collaboration**: Perfect for explaining processes, demonstrating bugs, or training
### Setting Up Project Collaboration
Before starting conversations, ensure your team is properly invited to collaborate:
#### Inviting Team Members to Projects
**Method 1: Share Link Invitation**
1. Navigate to your project
2. Click the **Share** button in the top-right corner
3. Select **Invite to project**
4. In the **Share link** tab, set permissions for new users
5. Click **Copy link** to share with team members
**Method 2: Direct Email Invitation**
1. Follow steps 1-3 above
2. Enter the email address of the team member
3. Click **Send Invite** to send the invitation
**Permission Levels:**
* **Full Access**: Complete project editing capabilities
* **Comment Only**: Can add comments but not edit content
* **View Only**: Read-only access to project content
### Project-Level Chat
Every project includes a built-in chat feature for focused team discussions:
#### Starting Team Chats
1. Open any project
2. Click the chat balloon icon (π¬) in the top-right corner
3. Choose **Team Chat** using the dropdown at the top of the chat box
4. Type your message and press **Enter** or click the arrow button
**Chat Interface Features:**
* **Real-time messaging** with all project members
* **Message history preservation** across sessions
* **File and media sharing** directly in conversations
* **Integration with project tasks** and updates
* **Typing indicators** to see when others are responding
* **Message timestamps** for chronological context
### Advanced Chat Features
**Enhanced Communication Capabilities:**
* **Threaded Discussions**: Keep conversations organized and on-topic
* **File Sharing**: Share documents, images, and files with inline previews
* **@Mentions**: Tag team members for immediate attention
* **Rich Formatting**: Use markdown for emphasis and structure
* **Emoji Reactions**: Quick responses without cluttering chat
* **Message Search**: Find important discussions and decisions
* **Chat History Export**: Export conversation logs for records
### Private Messaging
For confidential or one-on-one communications:
**Private Communication Options:**
* Create private projects for 1-on-1 conversations
* Direct messaging between team members
* Secure communication within workspace boundaries
* Encrypted message transmission
### Chat Management and Optimization
**Interface Controls:**
* **Hide/Show Chat Panel**: Toggle chat visibility as needed
* **Resize Chat**: Adjust chat panel width for optimal screen space
* **Chat History Search**: Find specific messages and discussions
* **Export Chat Logs**: Generate conversation records for compliance
**Performance Features:**
* **Message Synchronization**: Consistent chat history across devices
* **Offline Message Queue**: Send messages when connection is restored
* **Notification Controls**: Customize chat notification preferences
* **Chat Backup**: Automatic preservation of conversation history
## Video Calls
**Integrated Video Calling**
* Start video calls directly from any project
* No need for external meeting tools
* Seamless integration with project context
* Call history linked to project discussions
**Video Call Features**
* **Screen Sharing**: Share your screen for reviews and walkthroughs
* **Multi-Platform Support**: Works on desktop, web, and mobile
* **Project Context**: Discuss tasks while viewing the project
* **Recording**: Capture important meetings for later reference
**Use Cases**
* **Project Reviews**: Walk through tasks and deliverables
* **Brainstorming Sessions**: Collaborate on ideas in real-time
* **Client Presentations**: Share progress with stakeholders
* **Training Sessions**: Onboard new team members
## Presence & Availability
**Team Presence Indicators**
* **Online Status**: See who's currently active in the workspace
* **Project Activity**: Know which projects teammates are working on
**Distributed Team Support**
* **Time Zone Display**: See local times for all team members
* **Async Indicators**: Know when responses are expected
**Smart Notifications**
* **Summary Digests**: Catch up on activity while you were away
## Asynchronous Collaboration
**Async Communication Tools**
* **Task Comments**: Leave detailed feedback directly on tasks
* **@Mentions**: Tag team members for follow-up when they're available
* **Status Updates**: Keep everyone informed without interrupting focus
* **Threaded Discussions**: Maintain context in long conversations
**AI-Powered Collaboration**
* **AI-Summaries**: Taskade AI summarizes long discussions
* **Action Item Extraction**: AI identifies next steps
* **Meeting Notes**: AI generates structured notes from conversations
* **Smart Suggestions**: Get recommendations for improving collaboration
**Change Tracking & History**
* **Version History**: See what changed and when
* **Change Attribution**: Know who made specific edits
* **Rollback Capability**: Restore previous versions if needed
* **Audit Trail**: Complete history for compliance and review
## Collaboration Best Practices
### Communication Guidelines
* **Keep Context**: Use project chat to maintain discussion context
* **Decision Logging**: Document important decisions in task comments
* **Clear @Mentions**: Tag specific people for actions, not just awareness
* **Status Updates**: Provide regular progress updates for transparency
### Effective Async Work
* **Detailed Handoffs**: Leave comprehensive notes for the next person
* **Time Zone Awareness**: Schedule communications for recipient availability
* **Documentation**: Record decisions and rationale for future reference
* **AI Summaries**: Use Taskade AI to summarize complex discussions
### Team Coordination
* **Project Ownership**: Assign clear owners for each project
* **Regular Check-ins**: Schedule periodic sync meetings
* **Shared Standards**: Establish team conventions for naming and organization
* **Feedback Loops**: Create mechanisms for continuous improvement
## Mobile Collaboration
**On-the-Go Features**
* Full chat functionality on mobile devices
* Voice messages for quick updates
* Photo sharing from camera or gallery
* Push notifications for important updates
**Mobile-Specific Tools**
* **Quick Actions**: Rapid task creation and updates
* **Voice-to-Text**: Dictate messages and task updates
## Password Protection & Security
Add an extra layer of security to any shared content:
| **Content Type** | **Protection Level** | **Use Cases** |
| ---------------- | ------------------------ | --------------------------------------------- |
| **AI Agents** | Password-required access | Client-specific agents, premium consultations |
| **Forms** | Submission control | Exclusive surveys, internal feedback |
| **Automations** | Workflow security | Proprietary processes, client workflows |
| **Projects** | View/edit restrictions | Confidential documents, client work |
**How to Enable:**
1. **Share your content** (agent, form, automation, or project)
2. **Click "Add Password"** in the respective sharing settings
3. **Set a secure password** and share it separately
4. **Users must enter password** to access the content
**Security Benefits:**
* Prevents unauthorized access to shared links
* Adds professional layer for client work
* Controls access without complex permission systems
* Works with all Taskade sharing features
### **Privacy Controls**
* **Turn Off Chat/Comments**: Disable discussions for focused work environments
* **Selective Sharing**: Choose exactly what content gets shared with each person
* **Guest Access Management**: Control external user permissions and duration
* **Session Timeouts**: Automatic logout for security compliance
## Integration with AI Features
**AI-Enhanced Collaboration**
* **Smart Agents**: AI agents participate in project discussions
* **Automated Summaries**: AI creates meeting summaries and action items
* **Content Generation**: Collaborative content creation with AI assistance
* **Translation**: Translation for international teams
***
## **Enterprise Collaboration**
### **Advanced Team Communication**
**Structured Communication Channels**
| **Channel Type** | **Purpose** | **Features** | **Best For** |
| ------------------------ | ------------------------------- | --------------------------------------- | -------------------- |
| **Project Channels** | Task-focused discussions | Context-aware threads, file sharing | Development teams |
| **Executive Briefings** | Leadership communication | AI-generated summaries, priority alerts | C-suite coordination |
| **Client Collaboration** | External stakeholder engagement | Guest access, password protection | Client projects |
| **Emergency Channels** | Crisis communication | Instant alerts, escalation protocols | Incident response |
### **Advanced Video Conferencing**
**Integration Capabilities**
* **Calendar Sync**: Automatic meeting scheduling across platforms
* **Project Linking**: Meetings automatically linked to relevant projects
* **Follow-up Automation**: Action items become tasks with assignments
### **Global Team Coordination**
**Multi-Timezone Management**
```yaml
Global Team Features:
Timezone Intelligence:
- Automatic meeting time optimization
- Working hours awareness for notifications
- Handoff protocols between regions
- Follow-the-sun project management
Cultural Adaptation:
- Localized date/time formats
- Regional holiday calendars
- Communication style preferences
- Language-specific AI agents
```
**Asynchronous Collaboration Patterns**
| **Pattern** | **Implementation** | **Business Value** |
| -------------------------- | ------------------------------ | ----------------------- |
| **Relay Collaboration** | Work passes between timezones | 24/7 productivity |
| **Status Broadcasting** | Automated daily summaries | Transparent progress |
| **Decision Documentation** | AI-recorded decision rationale | Institutional knowledge |
| **Context Handoffs** | Rich project state transfers | Seamless transitions |
### **Compliance & Governance**
**Communication Compliance**
* **Message Retention**: Configurable retention policies for all communications
* **Legal Hold**: Preservation of communications for legal proceedings
* **Audit Trails**: Complete history of all collaboration activities
* **Content Filtering**: Automatic detection of sensitive information
**Governance Controls**
* **Communication Policies**: Automated enforcement of communication standards
* **Escalation Protocols**: Automatic routing of critical communications
* **Access Reviews**: Regular audits of collaboration permissions
* **Data Classification**: Automatic tagging of sensitive collaboration content
### **Advanced Analytics**
**Collaboration Intelligence**
```yaml
Team Performance Metrics:
Engagement Analysis:
- Message frequency and timing patterns
- Response time analytics
- Participation equity measurements
- Communication network analysis
Productivity Insights:
- Meeting effectiveness scores
- Collaboration tool usage patterns
- Knowledge sharing metrics
- Cross-functional interaction rates
Predictive Analytics:
- Team burnout risk indicators
- Project communication health
- Collaboration bottleneck detection
- Optimal team composition suggestions
```
**Executive Dashboards**
| **Metric Category** | **Key Indicators** | **Action Triggers** |
| -------------------- | ----------------------------------------- | ----------------------------- |
| **Team Health** | Communication frequency, response times | Low engagement alerts |
| **Project Velocity** | Decision speed, milestone discussions | Bottleneck warnings |
| **Knowledge Flow** | Information sharing patterns | Silo detection |
| **Innovation Index** | Cross-team collaboration, idea generation | Innovation opportunity alerts |
### **Security & Privacy**
**Enterprise-Grade Security**
* **End-to-End Encryption**: All communications encrypted in transit and at rest
* **Zero-Knowledge Architecture**: Taskade cannot access encrypted content
* **Advanced Authentication**: SAML SSO with conditional access policies
* **Device Management**: Mobile device compliance and remote wipe capabilities
**Privacy Controls**
* **Personal Data Protection**: GDPR/CCPA compliant data handling
* **Content Classification**: Automatic sensitivity labeling
* **Right to Deletion**: Complete data removal on request
***
## Project Updates & Changelog
### Automatic Change Tracking
{% hint style="info" %}
Taskade automatically tracks all project changes and sends consolidated updates to keep team members informed of important modifications.
{% endhint %}
**Changelog Features:**
* **Comprehensive Tracking**: Captures all task additions, edits, completions, and deletions
* **User Attribution**: Shows exactly who made each change (@username)
* **Project Context**: Includes direct links to affected projects and workspaces
* **Email Notifications**: Automatic changelog emails sent to project members
### Changelog Email Content
| Change Type | Description | Example |
| ------------------------- | ----------------------------------- | -------------------------------------- |
| **β Added Tasks** | New tasks created in the project | "Added 'Review marketing copy' task" |
| **βοΈ Edited Tasks** | Task content or properties modified | "Updated due date for Q1 campaign" |
| **β
Completed Tasks** | Tasks marked as finished | "Completed 'Design homepage mockup'" |
| **π€ Editor Attribution** | Shows who made the change | "@johndoe edited 'Budget review' task" |
### Accessing Project History
{% hint style="success" %}
View detailed project history directly within Taskade for complete change tracking and audit trails.
{% endhint %}
**History Features:**
* **Complete Timeline**: See all changes in chronological order
* **Search & Filter**: Find specific changes quickly
* **Export Options**: Download change logs for record keeping
* **Version Comparison**: Compare project states over time
### Changelog Management
**Notification Settings:**
* **Email Frequency**: Configure how often you receive changelog emails
* **Project Selection**: Choose which projects send changelog notifications
* **Change Types**: Filter notifications by type of change (additions, edits, completions)
* **Team Member Focus**: Receive updates only for specific team members' changes
**Best Practices:**
* **Regular Reviews**: Set aside time to review changelog emails
* **Team Communication**: Use changelogs to keep distributed teams aligned
* **Quality Assurance**: Monitor changes for consistency and accuracy
* **Documentation**: Use changelogs as project documentation and audit trails
## Chat and Comments Settings
**Control communication features in your projects** to create focused work environments or enable collaborative discussions.
### Managing Chat and Comments
**Project-level communication controls allow you to customize the collaboration experience** for different project types and team preferences.
#### Turning Off Chat and Comments
**Disable chat and comment features for focused work environments:**
**Configuration Steps:**
1. **Open Project**: Navigate to the project you want to modify
2. **Access Settings**: Click the βοΈ **gear icon** in the top right-hand corner
3. **Navigate to Settings**: Go to the βοΈ **Settings** tab in the project menu
4. **Toggle Features**: Use the toggles to disable chat and/or comments
5. **Save Changes**: Click outside the settings window to apply changes
**Visual Settings Interface:**
```
Project Menu (βοΈ) β Settings Tab β Chat/Comments Toggles β Save
```
#### Chat Control Options
**Selective Communication Management:**
* **Chat Disabled**: Completely hide the chat panel and prevent messaging
* **Chat Enabled**: Full chat functionality with real-time messaging
* **Chat Restricted**: Limit chat to specific team members or roles
#### Comments Control Options
**Task Comment Management:**
* **Comments Disabled**: Remove comment functionality from all tasks
* **Comments Enabled**: Allow full commenting on tasks and projects
* **Comments Moderated**: Require approval for comments to be visible
### Use Cases for Communication Controls
**Strategic Communication Management:**
#### Focused Work Environments
* **Disable chat** in projects requiring deep concentration
* **Turn off comments** during intensive development sprints
* **Minimize distractions** in time-sensitive or complex projects
#### Client Projects
* **Control communication** with external stakeholders
* **Maintain professional boundaries** with client interactions
* **Manage communication channels** for different project phases
#### Internal Team Projects
* **Enable full collaboration** for creative brainstorming sessions
* **Allow comments only** for review and feedback phases
* **Customize communication** based on team working styles
#### Educational and Training Projects
* **Structured communication** for learning environments
* **Guided discussions** with moderated comment features
* **Controlled interaction** during assessment periods
### Advanced Communication Settings
**Enterprise-level communication controls:**
#### Permission-Based Controls
* **Role-specific settings**: Different communication options for different team roles
* **Time-based restrictions**: Enable/disable communication during specific hours
* **Project-phase controls**: Adjust communication based on project lifecycle
#### Notification Management
**Stay organized with powerful notification controls:**
**Activity Space Overview:** The Activity space aggregates updates across your folders and workspaces, including project updates, new comments, and due dates. Access it by clicking the bell icon (π) in the top-right corner.
**Clearing Unread Notifications:**
{% stepper %}
{% step %}
#### Open Activity Space
Click the **π Bell icon** in the top-right corner of your Taskade interface.
{% endstep %}
{% step %}
#### Locate "Mark All As Read"
Find the **"Mark all as read"** button at the top of the Activity space.
{% endstep %}
{% step %}
#### Confirm Action
Click the button to clear all unread notifications.
{% endstep %}
{% endstepper %}
**Advanced Notification Controls:**
* **Chat notification settings**: Control when chat messages trigger notifications
* **Comment alert preferences**: Configure comment notification behavior
* **Bulk notification controls**: Manage notifications for multiple projects
* **Real-time vs batch notifications**: Choose immediate alerts or digest summaries
* **Platform-specific settings**: Different notification preferences for desktop, web, and mobile
#### Audit and Compliance
* **Communication logs**: Track all chat and comment activity
* **Export capabilities**: Generate communication reports for compliance
* **Retention policies**: Set data retention periods for communication history
## File Sharing and Cloud Integration
### Cloud Upload to Chat
**Share files and documents to chat directly from your cloud storage services:**
{% stepper %}
{% step %}
#### Access Upload Options
Click the **βοΈ Upload File** button at the bottom of the chat box, or drag & drop files directly.
{% endstep %}
{% step %}
#### Choose Upload Method
Select from local files, cloud storage (Google Drive, Dropbox), or drag & drop from your computer.
{% endstep %}
{% step %}
#### File Processing
Taskade automatically processes and makes your files available for AI chat and team collaboration.
{% endstep %}
{% endstepper %}
#### Supported File Formats
**Comprehensive file format support for all your content:**
**π Image/Design Formats:**
* Standard: `jpg`, `jpeg`, `png`, `gif`, `svg`, `webp`, `heic`
* Professional: `ai`, `bmp`, `eps`, `ico`, `ps`, `psd`, `tif`, `tiff`, `dwg`
**ποΈ Archive Formats:**
* `zip`, `tar`, `rar`, `gz`, `bz2`, `7z`, `lz`
**ποΈ Video Formats:**
* `3gp`, `flv`, `m4v`, `mov`, `mpg`, `mpeg`, `ogv`, `ogm`, `mkv`, `webm`, `wmv`, `vob`, `mp4`
**β¨οΈ Office Documents:**
* Microsoft: `docx`, `doc`, `pps`, `pptx`, `ppt`, `xlr`, `xlsx`, `xls`
* Other: `wks`, `wps`, `wpd`, `odt`, `odp`, `ods`
**π Text & eBooks:**
* `pdf`, `txt`, `rtf`, `tex`, `mobi`, `epub`
**π΅ Audio Formats:**
* `aif`, `mp3`, `mp2`, `mp4`, `m4a`, `mid`, `midi`, `opus`, `oga`, `spx`, `ogg`, `flac`, `wav`, `wma`
**π Apple Formats:**
* `numbers`, `pages`
**πΎ Database:**
* `teacher`, `pdb`, `trm`
**π‘ Font Formats:**
* `otf`, `ttf`, `pfa`, `woff`
### Media AI Chat
**Engage in AI-powered Q\&A sessions with your files and documents:**
{% hint style="success" %}
Transform the way you interact with documents and projects. Engage in productive Q\&A sessions with Taskade AI and ask questions about the contents of your projects, files, and attachments.
{% endhint %}
#### Method 1: Chat with Projects
**Ask AI questions about your entire project content:**
1. Open any project containing documents or content
2. Access the AI chat panel
3. Ask questions about project content, tasks, or structure
4. Get intelligent responses based on your project data
#### Method 2: Team + AI Collaborative Chat
**Chat about your documents with your team & Taskade AI simultaneously:**
* Team members and AI can participate in the same conversation
* AI provides insights while team members contribute expertise
* Perfect for collaborative document analysis and decision-making
* Maintains conversation history for future reference
#### Method 3: Chat with Attachments
**Direct Q\&A with specific files:**
{% stepper %}
{% step %}
#### Upload File
Add any supported file format to your project or chat
{% endstep %}
{% step %}
#### Access AI Chat
Click the AI chat option for the specific attachment
{% endstep %}
{% step %}
#### Ask Questions
Query the AI about the file's content, structure, or specific details
{% endstep %}
{% step %}
#### Get Insights
Receive intelligent responses based on the file's actual content
{% endstep %}
{% endstepper %}
#### Method 4: Media Manager Chat
**Centralized AI chat for all your media:**
* Access AI chat directly from the Media Manager
* Query multiple files simultaneously
* Organize and analyze your media library with AI assistance
* Perfect for managing large document collections
#### Media AI Chat Benefits
**Why use Media AI Chat:**
* **Document Analysis**: Extract key insights from complex documents
* **Content Summarization**: Get quick summaries of lengthy files
* **Data Extraction**: Pull specific information from structured documents
* **Collaborative Intelligence**: Combine human expertise with AI analysis
* **Cross-Reference**: Compare information across multiple documents
* **Accessibility**: Make document content searchable and queryable
### Communication Best Practices
**Optimizing Project Communication:**
#### When to Disable Chat
* **Deep work sessions**: Projects requiring uninterrupted focus
* **Time-critical tasks**: High-pressure deadlines and deliverables
* **Individual contributor work**: Solo work that doesn't need discussion
* **Sensitive information**: Projects handling confidential data
#### When to Disable Comments
* **Finalized content**: Projects where changes are no longer needed
* **Archived projects**: Historical projects that are reference-only
* **Template projects**: Standardized templates that shouldn't be modified
* **Review processes**: Structured approval workflows with dedicated channels
#### Communication Strategy
* **Project type assessment**: Evaluate communication needs for each project type
* **Team preference consideration**: Respect different team communication styles
* **Gradual implementation**: Start with pilot projects to test communication settings
* **Regular review**: Periodically reassess communication settings as projects evolve
### Troubleshooting Communication Issues
**Common Communication Setting Problems:**
#### Chat Not Appearing
* **Check project settings**: Verify chat is enabled in project configuration
* **Permission verification**: Ensure user has permission to access chat
* **Browser refresh**: Reload the page to apply setting changes
#### Comments Not Working
* **Comment toggle verification**: Confirm comments are enabled in settings
* **User permission check**: Verify user has commenting permissions
* **Task selection**: Ensure comments are being added to valid tasks
#### Setting Changes Not Applying
* **Save confirmation**: Click outside settings window to apply changes
* **Page refresh**: Reload the project to see updated settings
* **Workspace permissions**: Verify user has permission to modify project settings
***
**Related Features:**
* [AI Agents](/ai-features/ai-features/ai-agents-getting-started) - Collaborative AI assistants
* [Project Views](/workspaces/workspaces/project-views) - Visual collaboration tools
* [Mobile Optimization](/workspaces/workspaces/mobile-optimization) - Mobile collaboration features
* [Workspaces](/workspaces/workspaces) - Team organization and management
# Editing & Formatting
Format Taskade tasks with headings, lists, highlights, and 9 project views, plus add-ons like due dates, timers, and keyboard shortcuts.
***
## Table of Contents
* [Overview](#overview)
* [Format Tasks & Sub-Tasks](#format-tasks-and-sub-tasks)
* [Available Block Types](#available-block-types)
* [Project Views](#project-views)
* [Highlight & Style](#highlight-and-style)
* [Drag to Reorder](#drag-to-reorder)
* [Multi-Select Formatting](#multi-select-formatting)
* [Add-Ons Menu](#add-ons-menu)
* [Keyboard Shortcuts](#keyboard-shortcuts)
* [What's Next](#whats-next)
***
## Overview
Every Taskade project is a collection of **tasks** β structured like bullet points that can be nested into sub-tasks. You can format, style, reorder, and enhance tasks with add-ons like due dates, assignees, comments, timers, and custom fields.
> **Taskade Genesis hint:** Genesis apps use these same formatting and structuring capabilities in their project databases. Understanding formatting helps you build better apps.
***
## Format Tasks & Sub-Tasks
Taskade lets you turn tasks into checklists, headings, ordered lists, paragraphs, and more.
### How to Format
| Method | Steps |
| --------------------- | ------------------------------------------------------------------------------------------ |
| **Drag icon** | Click the six-dot drag icon to the left of a task β Click the first item β Select a format |
| **Slash command** | Type `/` followed by the format name (e.g., `/paragraph`, `/heading1`, `/checklist`) |
| **Keyboard shortcut** | Use shortcuts listed below |
***
## Available Block Types
| Format | Syntax (Slash Command) | Markdown Shortcut | Description |
| ----------------------- | ---------------------- | ----------------- | ------------------------------- |
| **Heading 1** | `/heading1` | `#` + space | Large section title |
| **Heading 2** | `/heading2` | `##` + space | Sub-section title |
| **Paragraph** | `/paragraph` | β | Plain text block |
| **Checklist** (Check 1) | `/checklist` | `[]` + space | Checkbox task item |
| **Circle Check** | `/circle-check` | β | Circle checkbox variant |
| **Bullet List** | `/bullet` | `-` + space | Unordered list item |
| **Numbered List** | `/numbered` | `1.` + space | Ordered list item |
| **Alphabetical List** | `/alpha` | β | Lettered list item (a, b, c...) |
| **Heart** | `/heart` | β | Heart icon task |
| **Triangle** | `/triangle` | β | Triangle icon task |
| **Square** | `/square` | β | Square icon task |
***
## Project Views
The same content can be displayed in **9 different views** β switch anytime without changing your data:
| View | Description | Best For |
| ---------------- | -------------------------------------------------------------------- | ---------------------------------- |
| **List** | Vertical list/to-do format with checkboxes and hierarchy | Task management, checklists, notes |
| **Board** | Kanban columns for workflow stages (drag-and-drop) | Pipeline management, sprints |
| **Table** | Structured spreadsheet-like format with filtering, sorting, grouping | Data management, CRM |
| **Calendar** | Events on calendar grid for deadline tracking | Scheduling, content calendars |
| **Gantt** | Timeline with task duration, dependencies, and progress | Project planning, milestones |
| **Mind Map** | Connected nodes radiating from center | Brainstorming, concept mapping |
| **Org Chart** | Hierarchical organizational structure | Team structure, process flows |
| **Action Sheet** | Compact action-oriented format | Quick task management |
***
## Highlight & Style
### Text Styling
| Style | Keyboard Shortcut (Mac) | Keyboard Shortcut (PC) | Markdown |
| ----------------- | ----------------------- | ---------------------- | -------------- |
| **Bold** | Cmd + B | Ctrl + B | `**text**` |
| **Italic** | Cmd + I | Ctrl + I | `_text_` |
| **Underline** | Cmd + U | Ctrl + U | `__text__` |
| **Strikethrough** | β | β | `~~text~~` |
| **Inline code** | β | β | `` `code` `` |
| **Block quote** | β | β | `> quote` |
| **Code block** | β | β | ` ```code``` ` |
### Color Highlights
| Method | Steps |
| -------------------- | ------------------------------------------------------------------------ |
| **Menu** | Select text β Click three dots β Select **A** (highlight) β Choose color |
| **Keyboard** | Select text β Cmd + E (Mac) / Ctrl + E (PC) β Cycle through colors |
| **Slash command** | Type `/red`, `/blue`, `/green`, etc. |
| **Remove highlight** | Select same color again, or press Cmd/Ctrl + E |
***
## Drag to Reorder
| Action | How |
| -------------------- | ------------------------------------------------------------------------- |
| **Reorder tasks** | Grab the six-dot drag icon to the left of any task β Drag to new position |
| **Nest as sub-task** | Drag a task underneath and to the right of another task |
| **Un-nest** | Drag a sub-task to the left to promote it |
| **Move sections** | Drag a top-level task to reorder its entire section (including sub-tasks) |
***
## Multi-Select Formatting
Format multiple tasks at once:
| Step | Action |
| ---- | ------------------------------------------------------------------------- |
| 1 | Highlight multiple tasks or lines of text with the mouse cursor |
| 2 | Apply formatting using the toolbar, slash commands, or keyboard shortcuts |
| 3 | All selected items are formatted simultaneously |
***
## Add-Ons Menu
Enhance tasks with additional features:
| Add-On | Shortcut (after Cmd + /) | Slash Command | Description |
| ------------------- | ------------------------ | ------------- | ---------------------------------------------------- |
| **Due Date** | D | `/duedate` | Set start/end dates with optional times |
| **Assign** | A | `/assign` | Assign to team members |
| **Comment** | C | `/comment` | Thread discussions on tasks |
| **Embed** | E | `/embed` | Embed media, links, or files |
| **Timer** | T | `/timer` | Track time spent on tasks |
| **Label/Tag** | β | `/tag` | Color-coded categorization |
| **Custom Fields** | β | `/field` | Add custom field values (text, number, date, select) |
| **File Attachment** | β | `/file` | Attach documents and media |
### Accessing the Add-Ons Menu
| Method | Steps |
| ----------------- | ------------------------------------------------------ |
| **Plus icon** | Click the **+** icon next to a task β Choose an add-on |
| **Keyboard** | Press **Cmd + /** then a letter (D, A, C, E, T) |
| **Slash command** | Type `/` followed by the add-on name |
***
## Keyboard Shortcuts
| Action | Mac | PC |
| ----------------- | -------------- | --------------- |
| Bold | Cmd + B | Ctrl + B |
| Italic | Cmd + I | Ctrl + I |
| Underline | Cmd + U | Ctrl + U |
| Highlight | Cmd + E | Ctrl + E |
| Add-ons menu | Cmd + / | Ctrl + / |
| Due date | Cmd + / then D | Ctrl + / then D |
| Assign | Cmd + / then A | Ctrl + / then A |
| Comment | Cmd + / then C | Ctrl + / then C |
| Embed | Cmd + / then E | Ctrl + / then E |
| Timer | Cmd + / then T | Ctrl + / then T |
| Indent (nest) | Tab | Tab |
| Outdent (un-nest) | Shift + Tab | Shift + Tab |
***
## What's Next
| Guide | What You'll Learn |
| ----------------------------------------------------------- | ------------------------------------ |
| [Markdown Support](/workspaces/workspaces/markdown) | Full Markdown syntax reference |
| [Import](/workspaces/workspaces/import) | Import .md and PDF files as projects |
| [Version History](/taskade-genesis/genesis/version-history) | Track and restore editing changes |
| [Embed Taskade](/workspaces/workspaces/embed) | Embed projects on your website |
# Markdown Support
Use Markdown in Taskade across the project editor, chat, comments, AI agent chat, import/export, and widgets. Full syntax reference for headings, lists, and formatting.
***
## Table of Contents
* [Overview](#overview)
* [Where Markdown Works in Taskade](#where-markdown-works-in-taskade)
* [Supported Syntax Reference](#supported-syntax-reference)
* [Markdown in the Project Editor](#markdown-in-the-project-editor)
* [Markdown in Chat & Comments](#markdown-in-chat-and-comments)
* [Markdown in Agent Chat](#markdown-in-agent-chat)
* [Markdown in AI Project Studio](#markdown-in-ai-project-studio)
* [Markdown in Browser Widgets & Quick Add](#markdown-in-browser-widgets-and-quick-add)
* [Import & Export Markdown](#import-and-export-markdown)
* [Add Markdown to Agent Knowledge](#add-markdown-to-agent-knowledge)
* [What's Next](#whats-next)
***
## Overview
Markdown is a lightweight markup language that uses characters like `*`, `#`, and `-` to format text. Taskade supports Markdown across **7 different surfaces** β from the project editor to AI agent chats, import/export, and browser widgets.
***
## Where Markdown Works in Taskade
| Surface | What Markdown Does |
| --------------------------- | -------------------------------------------------------------------------- |
| **Project editor** | Format tasks, checklists, headings, and paragraphs inline |
| **Import/Export** | Convert `.md` docs to projects and projects to `.md` files |
| **AI Project Studio** | Add `.md` files as context for AI-generated projects |
| **AI Agents** | Fine-tune agents using Markdown knowledge; structure prompts in agent chat |
| **Chat & Comments** | Format team messages and task comments |
| **Quick Add widget** | Add formatted notes and tasks from the desktop/browser widget |
| **Taskade Genesis Context** | Upload `.md` files as app-building context |
***
## Supported Syntax Reference
### Inline Formatting
| Feature | Syntax | Rendered Output |
| ----------------- | -------------------- | -------------------- |
| **Bold** | `**bold text**` | **bold text** |
| **Italic** | `_italic text_` | *italic text* |
| **Underline** | `__underlined__` | underlined |
| **Strikethrough** | `~~strikethrough~~` | ~~strikethrough~~ |
| **Inline code** | `` `code` `` | `code` |
| **Block quote** | `> quoted text` | > quoted text |
| **Code block** | ` ```code block``` ` | Formatted code block |
### Block Formatting (Project Editor)
Type these at the beginning of a line followed by a space:
| Syntax | Result | Description |
| -------------- | ------------- | ------------------- |
| `#` | H1 heading | Large section title |
| `##` | H2 heading | Sub-section title |
| `-` | Bullet list | Unordered list item |
| `1.` `2.` `3.` | Numbered list | Ordered list items |
| `[]` | Checklist | Checkbox task item |
### Links
| Feature | Syntax | Description |
| ------------------ | ------------------ | -------------------- |
| **Workspace link** | `"workspace link"` | Links to a workspace |
| **Project link** | `"project link"` | Links to a project |
| **Web link** | `[text](url)` | Standard hyperlink |
***
## Markdown in the Project Editor
Type Markdown syntax directly while editing tasks:
| Action | How |
| -------------------- | --------------------------------------- |
| Create heading | Type `#` or `##` at the start of a line |
| Create bullet list | Type `-` at the start of a line |
| Create numbered list | Type `1.` at the start of a line |
| Create checklist | Type `[]` at the start of a line |
| Bold text | Wrap text in `**double asterisks**` |
| Italic text | Wrap text in `_underscores_` |
| Code block | Wrap text in ` ``` ` |
***
## Markdown in Chat & Comments
### Chat
| Step | Action |
| ---- | ------------------------------------ |
| 1 | Open the project chat box |
| 2 | Wrap your message in Markdown syntax |
| 3 | Taskade renders the formatted text |
### Comments
| Step | Action |
| ---- | -------------------------------------------------------------- |
| 1 | Select a task β Click **+** β Select **Comments** (or press C) |
| 2 | Type your comment with Markdown syntax |
| 3 | Click send β Markdown is rendered |
***
## Markdown in Agent Chat
Use Markdown to structure prompts and get better AI responses:
| Technique | Example | Use Case |
| ---------------- | --------------------------------------------------------------- | --------------------------------- |
| **Emphasis** | `Fields marked with **bold** are mandatory.` | Highlight important instructions |
| **Code blocks** | ` ```python\ndef calculate(): ... ``` ` | Ask AI to analyze or debug code |
| **Lists** | `1. Download installer\n2. Accept license\n3. Choose directory` | Define step-by-step instructions |
| **Block quotes** | `> "Success is not final..."` | Emphasize key quotes or reminders |
***
## Markdown in AI Project Studio
Use `.md` files as context for AI-generated projects:
| Step | Action |
| ---- | ----------------------------------------------------- |
| 1 | Click **+ Create new** β **AI Project** |
| 2 | Describe the project you want |
| 3 | Click the upload dropdown β **Upload Files** |
| 4 | Upload your `.md` files as context |
| 5 | Generate the project β AI uses your Markdown as input |
***
## Markdown in Browser Widgets & Quick Add
| Method | Steps |
| --------------------- | -------------------------------------------------------------------------- |
| **Browser extension** | Right-click Taskade Extension β Add content with Markdown β Choose project |
| **Quick Add widget** | Open Quick Add β Write Markdown β Choose target project |
***
## Import & Export Markdown
### Import
| Method | Steps |
| --------------- | ------------------------------------------------------------------------- |
| **File upload** | **+ Create new** β **Import** β Drag `.md` files or click upload |
| **Paste** | **+ Create new** β **Import** β **Paste Text & Markdown** β Paste content |
| **Direct** | Visit `taskade.com/create` to start instantly |
### Export
| Step | Action |
| ---- | --------------------------------------------------------- |
| 1 | Click the three dots (β―) at the top-right of your project |
| 2 | Select **Export** β Choose **Markdown** |
| 3 | Download the `.md` file |
***
## Add Markdown to Agent Knowledge
Create Markdown knowledge sources directly in your agent:
| Step | Action |
| ---- | -------------------------------------------------------- |
| 1 | Go to **Agents** tab β Click three dots β **Edit agent** |
| 2 | Open the **Knowledge** tab |
| 3 | Click **Add Markdown/Text** |
| 4 | Paste Markdown or plain text into the pop-up |
| 5 | Click **Add to Knowledge** |
| 6 | Click **Update** in the Knowledge tab to save |
***
## What's Next
| Guide | What You'll Learn |
| ----------------------------------------------------------------- | ----------------------- |
| [Import](/workspaces/workspaces/import) | Full import walkthrough |
| [Editing & Formatting](/workspaces/workspaces/editing-formatting) | All formatting options |
# Import
Import Markdown, PDF, Word, Excel, CSV, and more into Taskade projects, or add files as AI agent knowledge, project context, and Taskade Genesis app context.
***
## Table of Contents
* [Import Markdown](#import-markdown)
* [Overview](#overview)
* [Import Markdown Files](#import-markdown-files)
* [Paste Text & Markdown](#paste-text-and-markdown)
* [Create Markdown Sources](#create-markdown-sources)
* [How AI Processing Works](#how-ai-processing-works)
* [Where Markdown Is Used in Taskade](#where-markdown-is-used-in-taskade)
* [Import PDF](#import-pdf)
* [Overview](#overview-1)
* [Convert PDF Into Projects](#convert-pdf-into-projects)
* [Add PDF as Agent Knowledge](#add-pdf-as-agent-knowledge)
* [Use PDF as Project Context](#use-pdf-as-project-context)
* [PDF in Automations](#pdf-in-automations)
* [What's Next](#whats-next)
***
## Import Markdown
### Overview
You can quickly create new Taskade projects from Markdown (.md) files. The importer preserves your formatting β headings, lists, bold/italic text, links, and images β while AI cleans up spacing and line breaks without changing meaning.
***
### Import Markdown Files
#### Step-by-Step Tutorial
| Step | Action |
| ---- | ----------------------------------------------------------------------- |
| 1 | Navigate to your workspace or folder |
| 2 | Click the **+ Create new** button |
| 3 | Select **Import** from the dropdown |
| 4 | **Option A:** Drag and drop `.md` files into the import box |
| 5 | **Option B:** Click **Paste Text & Markdown** to paste content directly |
| 6 | Click **Import** to finish |
#### Supported Import Formats
| Format | Extension | Notes |
| ---------- | --------------- | ------------------------------ |
| Markdown | `.md` | Full Markdown syntax preserved |
| Plain text | `.txt` | Converted to task structure |
| PDF | `.pdf` | See [Import PDF](#import-pdf) |
| Word | `.docx` | Structure preserved |
| PowerPoint | `.pptx` | Slides converted to sections |
| Excel | `.xlsx`, `.xls` | Tables preserved |
| CSV | `.csv` | Data converted to table view |
| EPUB | `.epub` | Chapters converted to sections |
{% hint style="info" %}
**Scanned and image-only files are supported.** When a PDF or document contains no machine-readable text (a scan, or a photo of a page), Taskade automatically transcribes it with vision OCR during extraction. OCR runs count toward your workspace's AI usage.
{% endhint %}
***
### Paste Text & Markdown
When you paste `.txt` or `.md` content directly, Taskade AI automatically cleans it up:
#### What AI Does
| Action | Example |
| ---------------------------- | ------------------------------ |
| Adds spacing and line breaks | Proper paragraph separation |
| Preserves bullet points | `- item` stays as a bullet |
| Preserves numbered lists | `1. item` stays numbered |
| Preserves headings | `## Title` becomes H2 |
| Preserves bold/italic | `**bold**` stays bold |
| Preserves links and images | URLs and image references kept |
#### What AI Does NOT Do
| Action | Guarantee |
| ------------------ | -------------------------- |
| Summarize content | Original content unchanged |
| Translate text | Language preserved |
| Add/remove meaning | No content modification |
| Add intro/outro | No extra text added |
| Comment on text | No AI commentary |
***
### Create Markdown Sources
Create `.md` files directly in Taskade and use them as project sources:
| Step | Action |
| ---- | -------------------------------------------------------- |
| 1 | Go to your workspace or folder |
| 2 | Click **+ Create new** β **AI Project** |
| 3 | Click **+ Add source** β **Paste text** |
| 4 | Paste Markdown-formatted text |
| 5 | The `.md` file is created and added to the **Media Tab** |
> Created Markdown documents can be used as agent knowledge, project context, or Taskade Genesis app context.
***
### How AI Processing Works
| Input | Output |
| --------------------- | -------------------------- |
| `## Task List` | **\[H2]** Task List |
| `- Buy milk` | Bullet: Buy milk |
| `1. Launch by Friday` | Numbered: Launch by Friday |
| `**Important**` | **Bold**: Important |
| `_Note_` | *Italic*: Note |
| `[Link](url)` | Clickable link |
***
### Where Markdown Is Used in Taskade
| Location | How Markdown Is Used |
| --------------------- | ---------------------------------------------------- |
| **Project editor** | Format tasks, checklists, and paragraphs inline |
| **Import/Export** | Convert `.md` files to projects and vice versa |
| **AI Project Studio** | Add `.md` files as context for AI-generated projects |
| **AI Agents** | Fine-tune agents using Markdown knowledge sources |
| **Chat & Comments** | Format messages with Markdown syntax |
| **Quick Add widget** | Add formatted notes and tasks |
| **Genesis Context** | Upload `.md` files as app-building context |
***
## Import PDF
### Overview
Taskade supports PDF import in three powerful ways: convert PDFs to structured projects, use them as AI agent knowledge, or add them as context for AI-generated projects. PDFs can also be processed in automation flows using the `pdf.convertToText` action.
> **Genesis connection:** Upload PDFs as Genesis context to create apps that match your existing documents, forms, and processes.
***
### Convert PDF Into Projects
Turn any PDF into a structured Taskade project:
| Step | Action |
| ---- | ----------------------------------------------------------- |
| 1 | Click **+ Create new** in your workspace (top-right corner) |
| 2 | Choose **Import** from the dropdown |
| 3 | Select an import mode: |
| Mode | What It Does |
| ---------------------- | ----------------------------------------------------------------------------- |
| **Convert to Taskade** | Converts the PDF into a structured project with headings, tasks, and sections |
| **Summarize with AI** | Creates a concise summary of the PDF in a new project |
| Step | Action |
| ---- | ---------------------------------------------------- |
| 4 | Drag files into the box or click to upload |
| 5 | Wait for the importer to process |
| 6 | Click **+ Create Project** to create the new project |
***
### Add PDF as Agent Knowledge
Train your AI agents on PDF content:
| Step | Action |
| ---- | --------------------------------------------------------------------- |
| 1 | Go to your workspace β **Agents** tab |
| 2 | Click the three dots (β―) next to your agent β **Edit agent** |
| 3 | Open the **Knowledge** tab |
| 4 | Enable agent knowledge (toggle on) |
| 5 | **Option A:** Drag PDF files into the box, or click to upload |
| 6 | **Option B:** Click **Add Media** to select files from your workspace |
> **Result:** Your agent can now answer questions using information from the uploaded PDFs. References are cited in agent responses.
***
### Use PDF as Project Context
Use PDFs as seed data for AI-generated projects:
| Step | Action |
| ---- | --------------------------------------------------- |
| 1 | Click **+ Create new** β **AI Project** |
| 2 | Describe the project you want to generate |
| 3 | Click **Upload Files** and upload your `.pdf` files |
| 4 | Click Enter to generate the project |
> **What happens:** AI reads the PDF content and uses it as context to generate a more relevant, customized project.
***
### PDF in Automations
PDFs can be processed automatically within automation flows:
| Action | What It Does | Use Case |
| ------------------------ | ----------------------------------- | --------------------------------------------- |
| **pdf.convertToText** | Converts PDF content to plain text | Extract text for AI analysis, data processing |
| **Upload File to Media** | Saves PDF to workspace Media | Archive incoming attachments |
| **Agent Knowledge Add** | Adds PDF content to agent knowledge | Auto-train agents on new documents |
#### Example Automation Flow
| Step | Action |
| -------- | ----------------------------------------- |
| Trigger | New Email with PDF attachment (Gmail) |
| Action 1 | Loop through attachments |
| Action 2 | Convert PDF to text (`pdf.convertToText`) |
| Action 3 | AI summarizes the text (`ai.generate`) |
| Action 4 | Create task with summary in project |
| Action 5 | Notify team on Slack |
***
## What's Next
| Guide | What You'll Learn |
| ----------------------------------------------------------------- | ------------------------------------------------------- |
| [Markdown Support](/workspaces/workspaces/markdown) | Full syntax reference and usage guide |
| [Editing & Formatting](/workspaces/workspaces/editing-formatting) | Format tasks and projects |
| [REST API Guide](/developers/comprehensive-api-guide) | Import and create projects programmatically via the API |
# Embed
Embed Taskade projects and Genesis apps on any site via iframe, set theme and size, and embed Google Docs, Figma, Loom, YouTube inside projects.
***
## Table of Contents
* [Overview](#overview)
* [Embed a Project](#embed-a-project)
* [Embed Settings](#embed-settings)
* [Supported Embed Sources (In Taskade)](#supported-embed-sources-in-taskade)
* [Embed Taskade Genesis Apps](#embed-genesis-apps)
* [What's Next](#whats-next)
***
## Overview
You can embed entire Taskade projects on your website or blog and keep everyone on the same page. Any changes you make will be **instantly visible** to your audience. You can also embed external content inside Taskade projects.
> **Genesis connection:** Genesis apps can be embedded on any website using iframe. Published apps also support custom domains for white-label embedding. See [Publish and Clone Your Apps](/community-and-sharing/community-and-sharing/publish-and-clone).
***
## Embed a Project
### Step-by-Step Tutorial
| Step | Action |
| ---- | --------------------------------------------------------------- |
| 1 | Open a project and switch to your desired project view |
| 2 | Click the **Share** button in the top-right corner |
| 3 | Select the **< > Embed** tab |
| 4 | Click **Copy** to copy the embed code |
| 5 | Paste the embed code into your website or blog HTML |
| 6 | *(Optional)* Customize theme, dimensions, and footer visibility |
### Embed Code Example
```html
```
***
## Embed Settings
| Setting | Options | Description |
| --------------------- | ------------------------ | ------------------------------------------- |
| **Cover image style** | Banner, Background, None | Controls how the project cover displays |
| **Dimensions** | Custom width/height | Set iframe size (default: 80% width/height) |
| **Theme** | Light, Dark, Auto | Match your website's color scheme |
| **Editing access** | View only, Edit allowed | Control whether embedded viewers can edit |
| **Footer visibility** | Show, Hide | Toggle the Taskade footer bar |
***
## Supported Embed Sources (In Taskade)
You can embed external content inside Taskade projects using the Embed add-on:
| Platform | URL Pattern | Description |
| ------------------ | ----------------------------------- | ---------------------------------------- |
| **Google Docs** | `docs.google.com/document/...` | Embed Google Documents |
| **Google Sheets** | `docs.google.com/spreadsheets/...` | Embed Google Spreadsheets |
| **Canva** | `design.canva.com/...` | Embed Canva designs |
| **Figma** | `figma.com/...` | Embed Figma designs and prototypes |
| **Loom** | `loom.com/share/...` | Embed Loom videos |
| **Vimeo** | `vimeo.com/...` | Embed Vimeo videos |
| **Wistia** | `wistia.com/...` | Embed Wistia videos |
| **YouTube** | `youtube.com/...` or `youtu.be/...` | Embed YouTube videos |
| **SoundCloud** | `soundcloud.com/...` | Embed SoundCloud audio tracks |
| **Spotify** | `open.spotify.com/embed/track/...` | Embed Spotify tracks |
| **Instagram** | `instagram.com/p/...` | Embed Instagram posts |
| **Typeform** | `typeform.com/...` | Embed Typeform forms |
| **Whimsical** | `whimsical.com/...` | Embed Whimsical boards |
| **InVision** | InVision embed URLs | Embed InVision prototypes |
| **PDF files** | Any `.pdf` URL | Embed PDF documents with viewer |
| **Markdown files** | Any `.md` URL | Embed Markdown with preview |
| **Any URL** | Any web URL | Embed as iframe with Open Graph metadata |
### How to Embed Content in a Project
| Method | Steps |
| ----------------- | --------------------------------------------------------- |
| **Add-on menu** | Click **+** next to a task β Select **Embed** β Paste URL |
| **Keyboard** | Press **Cmd + /** then **E** β Paste URL |
| **Slash command** | Type `/embed` β Paste URL |
| **Drag & drop** | Drag a file or link into the project editor |
***
## Embed Genesis Apps
Genesis apps can be embedded on any website:
| Method | How | Plan |
| ----------------- | --------------------------------------------- | --------- |
| **iframe embed** | Copy the embed code from the Publish settings | All plans |
| **Direct link** | Share the published app URL | All plans |
| **Custom domain** | Point your domain to the app (CNAME) | Business+ |
***
## What's Next
| Guide | What You'll Learn |
| ----------------------------------------------------------------- | ------------------------------------- |
| [Editing & Formatting](/workspaces/workspaces/editing-formatting) | Format and style your project content |
| [Markdown Support](/workspaces/workspaces/markdown) | Use Markdown in embedded projects |
| [Taskade for Teams](/workspaces/workspaces/teams) | Share embedded projects with teams |
# Project Views
Switch Taskade projects between List, Board, Table, Calendar, Mind Map, Gantt, and more views on the same data, plus custom field types and Fill with AI.
Taskade stores information in a flexible tree-structured database. The **same data** can be visualized in multiple ways to suit different workflows. These presentation modes are called **Project Views**.
[**Projects & Databases Guide β**](https://www.taskade.com/learn/projects/databases)
{% hint style="success" %}
Your data lives in one place, but you can view it through many lenses. Switch views instantly β no conversion, no data loss. Each view simply emphasizes a different aspect of the same underlying tree.
{% endhint %}
## Views Reference
| View | Best For | Key Interactions | Use Cases |
| --------------- | -------------------------------------- | ----------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
| **List** | Linear task lists, meeting agendas | Drag-to-indent / reorder, checkboxes | To-do lists, meeting notes, SOPs |
| **Board** | Kanban workflows, pipelines | Drag cards between columns | Sales pipelines, project stages, sprint boards |
| **Table** | Spreadsheet-style databases | Inline edit custom fields, sort & filter, multi-select rows (Shift/Cmd-click) + bulk delete with undo | CRM, inventory, contact lists |
| **Calendar** | Scheduling & deadlines | Drag tasks on calendar, date pickers | Content calendars, event planning, deadlines |
| **Mind Map** | Brain-storming & hierarchical planning | Radial drag to create branches | Strategy planning, idea mapping, research |
| **Org Chart** | Organizational hierarchies | Expand / collapse levels | Team structures, reporting lines, decision trees |
| **Action** | Mobile-friendly task capture | Quick-add, swipe to complete | Daily tasks, quick capture, on-the-go |
| **Gantt** | Timeline & dependency tracking | Resize bars to adjust durations | Project timelines, resource planning, dependencies |
| **Docs (Beta)** | Long-form documents & wikis | Continuous rich-text editing, headings, embeds | Specs, knowledge bases, proposals, SOPs |
All views are backed by the **same underlying data** β update a task in one view and it instantly updates everywhere, thanks to Taskade's real-time engine.
> π‘ **Tip:** Use the `/view` slash-command or the View switcher in the top-right corner of any project to toggle between visualizations.
> π€ **Export any view.** The project's **β― More menu > Export** works in every view β including Mind Map, Board, Calendar, and Org Chart β on all plans. CSV export flattens the task tree (depth, text, note, completed) for spreadsheets and BI tools; Markdown export preserves the outline.
## When to Use Each View
A short guide to the situations each view is built for.
{% tabs %}
{% tab title="List" %}
**Reach for List when work is linear or hierarchical.**
* Step-by-step processes and standard operating procedures
* Meeting agendas with clear progression
* Checklists, outlines, and content planning
* Quick task capture and brain dumps
Indent freely to build a tree: major categories at the top level, sub-processes beneath them, and specific action items (with assignees and dates) at the deepest level.
{% endtab %}
{% tab title="Board" %}
**Reach for Board when work moves through stages.**
* Kanban workflows and pipeline management
* Status tracking with clear hand-offs between people or teams
* Sales / lead management and editorial workflows
* Sprint and project-phase tracking
Each column is a stage; drag a card to move work forward. Keep card titles short and actionable, and limit labels and assignees per card so the board stays scannable.
{% endtab %}
{% tab title="Table" %}
**Reach for Table when you need structured, sortable data.**
* Database-like records with sorting and filtering
* CRM, contact lists, and inventory
* Budget and financial tracking
* Reporting and analysis
Define custom fields (text, number, date, select, person, formula, relation, and more) to give each row structure, then sort and filter to surface what matters.
{% endtab %}
{% tab title="Calendar" %}
**Reach for Calendar when timing matters.**
* Event planning and scheduling coordination
* Deadline and milestone tracking
* Editorial calendars and content planning
* Personal time blocking
Drag tasks onto dates and switch between daily, weekly, and monthly modes for detail vs. overview.
{% endtab %}
{% tab title="Mind Map" %}
**Reach for Mind Map when you're thinking, not yet executing.**
* Brainstorming and idea generation
* Concept and knowledge mapping
* Creative planning and problem solving
Put the core topic at the center, branch into a handful of main themes, then expand outward to specific ideas and next steps.
{% endtab %}
{% tab title="Org Chart" %}
**Reach for Org Chart to show hierarchy and flow.**
* Organizational and reporting structures
* Decision trees and process flows
* Product hierarchies and categorization
Expand and collapse levels to move between the big picture and the details.
{% endtab %}
{% tab title="Action" %}
**Reach for Action when you're mobile or moving fast.**
* On-the-go task management
* Quick capture without complex formatting
* Simple, focused daily workflows
A clean, single-column layout with large touch targets and swipe-to-complete gestures.
{% endtab %}
{% tab title="Gantt" %}
**Reach for Gantt when timelines and dependencies are central.**
* Project scheduling with dependencies
* Resource allocation and capacity planning
* Milestone tracking and progress reporting
Resize bars to adjust durations and link tasks to model dependency relationships (finish-to-start, start-to-start, finish-to-finish, start-to-finish).
{% endtab %}
{% endtabs %}
## Switching Views Across a Project's Lifecycle
The right view often changes as a project evolves. A common progression:
{% stepper %}
{% step %}
### Ideation
Use **Mind Map** to brainstorm, then **List** to capture and roughly organize the output.
{% endstep %}
{% step %}
### Planning
Use **Gantt** to lay out the timeline and **Table** to track resources and structured details.
{% endstep %}
{% step %}
### Execution
Use **Board** to manage workflow stages and **Action** for daily, on-the-go task completion.
{% endstep %}
{% step %}
### Review
Use **Calendar** to look back across the timeline and **Table** to review records and outcomes.
{% endstep %}
{% endstepper %}
{% hint style="info" %}
Match the view to the job. Gantt is overkill for a simple checklist; Action View is too lightweight for detailed planning; Table is restrictive for open-ended brainstorming. Keep custom fields and naming consistent so switching views stays seamless.
{% endhint %}
## Focus Management: Hide Completed Tasks (List View)
Keep long-running projects clutter-free by hiding completed tasks while still tracking progress.
{% stepper %}
{% step %}
### Open project options
Click the three dots (Β·Β·Β·) in the top-right corner of your project.
{% endstep %}
{% step %}
### Toggle visibility
Select **Hide completed** from the dropdown menu.
{% endstep %}
{% step %}
### Track progress
The progress bar at the top continues to fill as tasks are completed, even when they're hidden.
{% endstep %}
{% endstepper %}
* Set a default behavior for all projects in a workspace; individual projects can override it.
* Complete a task quickly with `β + Enter` (Mac) or `Ctrl + Enter` (Windows/Linux).
## Fill with AI (Table View)
In Table View, **Taskade EVE** can populate columns automatically by analyzing the data already in each row β turning the table into an AI-assisted processing tool.
| AI Action | What It Does | Example Use |
| ------------------- | --------------------------------------------- | ------------------------------------ |
| **Translate** | Convert text into another language | Multi-language customer data |
| **Summarize** | Condense long text into key points | Turning feedback into takeaways |
| **Extract** | Pull specific values out of unstructured text | Automated data entry |
| **Categorize** | Auto-assign tags or labels | Consistent record organization |
| **Custom analysis** | Run a prompt you define against each row | Tailored, business-specific insights |
{% hint style="info" %}
Fill with AI works on the data in your table. Results are suggestions β review them before relying on them, especially for decisions.
{% endhint %}
## Field Types Reference
Projects support custom fields for structured data storage:
| Field Type | Description | Use Cases |
| ------------ | ------------------------------- | ---------------------------------------- |
| **Text** | Single or multi-line text | Names, descriptions, notes |
| **Number** | Numeric values | Prices, quantities, scores |
| **Date** | Date and time values | Deadlines, schedules, milestones |
| **Select** | Dropdown options (single/multi) | Status, categories, priorities |
| **Person** | Team member assignment | Assignees, owners, reviewers |
| **Checkbox** | True/false toggle | Completion flags, approvals |
| **URL** | Web links | References, resources, documents |
| **Email** | Email addresses | Contact information |
| **Phone** | Phone numbers | Contact information |
| **File** | Attachments | Documents, images, assets |
| **Formula** | Calculated values | Totals, averages, derived data |
| **Relation** | Links to other projects | Dependencies, parent/child relationships |
## View Selection Guide
| If You Need To... | Use This View |
| ------------------------- | ----------------- |
| Track tasks with subtasks | List |
| Visualize workflow stages | Board |
| Manage structured data | Table |
| Plan by date | Calendar or Gantt |
| Brainstorm ideas | Mind Map |
| Show team hierarchy | Org Chart |
| Quick mobile capture | Action |
### API Considerations
The REST and GraphQL APIs expose **data only**; view choice is a client-side concern. Use the `view` query parameter in certain list endpoints (or the `X-Taskade-View` header) to request server-optimized payloads for large Gantt or Calendar renders.
[**API Documentation β**](https://www.taskade.com/api/documentation/)
[**REST API v1 Guide β**](/developers/comprehensive-api-guide)
***
# Advanced Search & Navigation
Find anything in Taskade fast with global search, smart filters, search operators, natural-language queries, the command palette, and keyboard navigation.
Master Taskade's powerful search capabilities and navigation features to quickly find information, projects, and content across your entire workspace ecosystem.
{% hint style="success" %}
Taskade's advanced search and navigation system transforms how you discover and access information. With intelligent search algorithms, contextual filters, and smart navigation shortcuts, you can find exactly what you need in seconds, not minutes.
{% endhint %}
## Overview
As your Taskade workspace grows with projects, documents, and team collaboration, finding specific information becomes crucial for productivity. Our advanced search and navigation features provide multiple ways to quickly locate content, understand relationships between projects, and navigate efficiently across your entire workspace.
### Key Search Features
* **π Global Search**: Search across all projects, tasks, and content simultaneously
* **π― Smart Filters**: Narrow results by type, date, assignee, and custom criteria
* **π§ AI-Powered Search**: Natural language queries and intelligent content suggestions
* **π± Cross-Platform**: Consistent search experience across web, desktop, and mobile
* **β‘ Real-Time Results**: Instant search results as you type
* **π Contextual Navigation**: Smart links and related content discovery
## Global Search System
### Universal Search Bar
**Access everything from one search interface:**
{% stepper %}
{% step %}
#### Access Global Search
Click the search icon (π) in the top navigation or use keyboard shortcut **Ctrl/Cmd + K**.
{% endstep %}
{% step %}
#### Enter Search Query
Type your search terms, keywords, or natural language questions.
{% endstep %}
{% step %}
#### Review Results
Browse categorized results including projects, tasks, documents, and team members.
{% endstep %}
{% step %}
#### Navigate to Content
Click any result to navigate directly to the relevant content.
{% endstep %}
{% endstepper %}
### Search Query Types
**Different ways to search for content:**
#### Keyword Search
* **Simple Keywords**: `meeting notes`, `budget planning`, `client feedback`
* **Exact Phrases**: `"quarterly review"`, `"project deadline"`
* **Partial Matches**: `proj*` (finds project, projects, projections)
* **Boolean Operators**: `marketing AND campaign NOT social`
#### Natural Language Queries
* **Questions**: "What are my overdue tasks?"
* **Commands**: "Show me projects from last month"
* **Contextual**: "Find documents related to the Johnson account"
* **Temporal**: "Tasks due this week in the marketing workspace"
#### Advanced Search Operators
```
# Search operators and examples
title:budget # Search in titles only
assignee:john # Find content assigned to John
created:2024 # Content created in 2024
modified:last-week # Recently modified content
type:project # Search only projects
workspace:marketing # Search within specific workspace
tag:urgent # Find content with specific tags
```
## Search Filters and Categories
### Content Type Filters
**Filter results by content type:**
#### Project Content
* **Projects**: Complete projects and their metadata
* **Tasks**: Individual tasks and subtasks
* **Notes**: Text content and documentation
* **Comments**: Discussion threads and feedback
* **Attachments**: Files, images, and media
#### Team Content
* **Team Members**: User profiles and contact information
* **Workspaces**: Workspace descriptions and settings
* **Folders**: Organizational structures and hierarchies
* **Templates**: Project templates and frameworks
* **Automations**: Workflow automations and triggers
### Advanced Filtering Options
**Refine search results with sophisticated filters:**
{% tabs %}
{% tab title="Date Filters" %}
**Temporal Filtering**
* **Created Date**: When content was originally created
* **Modified Date**: When content was last updated
* **Due Date**: When tasks or projects are due
* **Completion Date**: When items were marked complete
**Date Range Options:**
* Today, Yesterday, This Week, Last Week
* This Month, Last Month, This Quarter
* This Year, Last Year, Custom Range
* Relative dates: "2 weeks ago", "3 months from now"
{% endtab %}
{% tab title="People Filters" %}
**User-Based Filtering**
* **Created By**: Who originally created the content
* **Assigned To**: Who is responsible for tasks or projects
* **Last Modified By**: Who made the most recent changes
* **Shared With**: Who has access to the content
**Team Filtering:**
* Individual team members
* User groups and roles
* Department or team assignments
* External collaborators and guests
{% endtab %}
{% tab title="Status Filters" %}
**Content Status**
* **Completion Status**: Complete, incomplete, in progress
* **Project Status**: Active, archived, on hold, completed
* **Priority Levels**: High, medium, low priority items
* **Workflow Stages**: Custom workflow status options
**Visibility Filters:**
* Public vs. private content
* Shared vs. personal items
* Workspace vs. folder content
* Template vs. regular projects
{% endtab %}
{% endtabs %}
### Smart Search Suggestions
**AI-powered search assistance:**
#### Auto-Complete
* **Query Completion**: Suggests complete search terms as you type
* **Recent Searches**: Quick access to your recent search queries
* **Popular Searches**: Commonly searched terms in your workspace
* **Contextual Suggestions**: Relevant suggestions based on current project
#### Related Content Discovery
* **Similar Projects**: Find projects with related content or themes
* **Connected Tasks**: Discover tasks linked to your current work
* **Team Collaboration**: Find content you've collaborated on with specific team members
* **Topic Clustering**: Group related content by themes or subjects
## Navigation Shortcuts and Commands
### Keyboard Navigation
**Efficient keyboard shortcuts for power users:**
#### Global Navigation
* **Ctrl/Cmd + K**: Open global search
* **Ctrl/Cmd + /**: Open command palette
* **Ctrl/Cmd + Shift + P**: Open project switcher
* **Alt + H**: Navigate to home/dashboard
* **Alt + W**: Switch between workspaces
#### Within Projects
* **Tab**: Navigate between tasks
* **Enter**: Edit selected task
* **Esc**: Exit editing mode
* **Ctrl/Cmd + Enter**: Create new task
* **Ctrl/Cmd + D**: Duplicate current task
#### Search Navigation
* **β/β Arrow Keys**: Navigate search results
* **Enter**: Open selected result
* **Ctrl/Cmd + Enter**: Open in new tab
* **Esc**: Close search interface
### Command Palette
**Quick access to all Taskade features:**
{% stepper %}
{% step %}
#### Open Command Palette
Press **Ctrl/Cmd + /** or click the command icon in the navigation.
{% endstep %}
{% step %}
#### Type Command
Start typing the action you want to perform (e.g., "create project", "invite user").
{% endstep %}
{% step %}
#### Select Action
Use arrow keys to select the desired command and press Enter.
{% endstep %}
{% step %}
#### Execute Command
The selected action will be performed immediately.
{% endstep %}
{% endstepper %}
#### Available Commands
* **Project Management**: Create, duplicate, archive, share projects
* **Task Operations**: Add, edit, complete, assign tasks
* **Team Actions**: Invite users, manage permissions, create workspaces
* **View Controls**: Switch views, filter content, sort items
* **System Functions**: Export data, manage settings, access help
### Quick Navigation Panels
**Streamlined access to frequently used content:**
#### Recent Items Panel
* **Recent Projects**: Last 10 projects you've accessed
* **Recent Tasks**: Recently created or modified tasks
* **Recent Documents**: Recently opened or edited documents
* **Recent Searches**: Your most recent search queries
#### Favorites and Bookmarks
* **Starred Projects**: Projects you've marked as favorites
* **Bookmarked Tasks**: Important tasks saved for quick access
* **Frequent Collaborators**: Team members you work with most
* **Saved Searches**: Frequently used search queries
## AI-Powered Search Intelligence
### Natural Language Processing
**Search using conversational language:**
#### Question-Based Queries
* "What tasks are overdue in the marketing project?"
* "Show me all documents created by Sarah last month"
* "Find projects related to the Q4 budget planning"
* "Which team members are working on the website redesign?"
#### Intent Recognition
* **Action Queries**: "Create a new project for client onboarding"
* **Information Queries**: "How many tasks are completed this week?"
* **Navigation Queries**: "Go to the project dashboard"
* **Status Queries**: "What's the status of the mobile app project?"
### Contextual Search
**Search that understands your current context:**
#### Project-Aware Search
* **Current Project Context**: Prioritize results from your current project
* **Related Project Discovery**: Find projects connected to your current work
* **Team Context**: Show results relevant to your current team members
* **Workspace Scope**: Focus results within your current workspace
#### Temporal Context
* **Recent Activity**: Prioritize recently accessed or modified content
* **Upcoming Deadlines**: Highlight content with approaching due dates
* **Seasonal Relevance**: Surface content relevant to current time periods
* **Work Pattern Recognition**: Learn from your usage patterns to improve results
### Smart Content Recommendations
**Proactive content discovery:**
#### Related Content Suggestions
* **Similar Projects**: Projects with similar themes or content
* **Connected Tasks**: Tasks that reference or link to current content
* **Team Collaborations**: Content you've worked on with specific team members
* **Follow-up Items**: Tasks or projects that are logical next steps
#### Learning Algorithms
* **Usage Patterns**: Learn from your search and navigation behavior
* **Collaboration Networks**: Understand your team collaboration patterns
* **Content Relationships**: Identify connections between different pieces of content
* **Preference Learning**: Adapt to your preferred content types and formats
## Mobile Search and Navigation
### Mobile-Optimized Search
**Full search capabilities on mobile devices:**
#### Touch-Friendly Interface
* **Large Search Bar**: Easy-to-tap search interface
* **Voice Search**: Speak your search queries using voice recognition
* **Gesture Navigation**: Swipe through search results and categories
* **Quick Filters**: One-tap access to common filter options
#### Mobile-Specific Features
* **Location-Based Search**: Find content related to your current location
* **Offline Search**: Search recently accessed content without internet
* **Push Notifications**: Get notified when searched content is updated
* **Quick Actions**: Perform actions directly from search results
### Mobile Navigation Shortcuts
**Efficient mobile navigation:**
#### Gesture Controls
* **Swipe Right**: Open navigation menu
* **Swipe Left**: Access recent items
* **Pull Down**: Refresh current view
* **Long Press**: Access context menu
#### Quick Access
* **Floating Action Button**: Quick access to create new content
* **Bottom Navigation**: Switch between main sections
* **Search Widget**: Add search widget to home screen
* **Shortcuts**: Create shortcuts for frequently accessed content
## Advanced Search Techniques
### Search Optimization Strategies
**Get better search results with advanced techniques:**
#### Query Refinement
* **Use Specific Terms**: Choose precise keywords over general terms
* **Include Context**: Add context words to narrow results
* **Use Synonyms**: Try alternative words if initial search doesn't work
* **Combine Operators**: Use multiple search operators together
#### Result Analysis
* **Review All Categories**: Check different result categories (projects, tasks, people)
* **Use Filters Progressively**: Start broad, then narrow with filters
* **Check Related Suggestions**: Explore AI-suggested related content
* **Save Successful Queries**: Bookmark effective search queries
### Search Performance Tips
**Optimize search speed and accuracy:**
#### Best Practices
* **Keep Keywords Relevant**: Use terms that actually appear in your content
* **Use Consistent Naming**: Maintain consistent naming conventions across projects
* **Tag Important Content**: Use tags to make content more discoverable
* **Regular Content Review**: Periodically review and organize content
#### Common Pitfalls to Avoid
* **Too Broad Queries**: Avoid single-word searches that return too many results
* **Typos and Misspellings**: Double-check spelling in search queries
* **Outdated Information**: Update search expectations as content evolves
* **Ignoring Filters**: Use filters to narrow down large result sets
## Search Analytics and Insights
### Search Performance Metrics
**Understand how search is used in your workspace:**
#### Usage Analytics
* **Popular Search Terms**: Most frequently searched keywords
* **Search Success Rates**: Percentage of searches that lead to content access
* **Result Click-Through**: Which types of results are clicked most often
* **Search Abandonment**: Queries that don't result in content access
#### Content Discovery Insights
* **Frequently Accessed Content**: Most popular projects and tasks
* **Search-Driven Discovery**: Content found primarily through search
* **Navigation Patterns**: How users move through your workspace
* **Collaboration Networks**: How search facilitates team collaboration
### Improving Searchability
**Make your content more discoverable:**
#### Content Optimization
* **Descriptive Titles**: Use clear, descriptive project and task titles
* **Comprehensive Tags**: Apply relevant tags to categorize content
* **Detailed Descriptions**: Include searchable keywords in descriptions
* **Consistent Terminology**: Use consistent language across similar content
#### Workspace Organization
* **Logical Structure**: Organize content in intuitive hierarchies
* **Clear Naming Conventions**: Establish and follow naming standards
* **Regular Cleanup**: Archive or delete outdated content
* **Search Training**: Train team members on effective search techniques
## Integration with External Search
### Third-Party Search Integration
**Connect Taskade search with external systems:**
#### Cloud Storage Search
* **Google Drive**: Search Google Drive files from within Taskade
* **Dropbox**: Find Dropbox documents through Taskade search
* **OneDrive**: Access OneDrive content via integrated search
* **Box**: Search Box files and folders from Taskade interface
#### Communication Platform Search
* **Slack**: Find Slack messages and files through Taskade
* **Microsoft Teams**: Search Teams conversations and documents
* **Discord**: Access Discord messages and shared files
* **Email**: Search email content and attachments
### API-Based Search Extensions
**Extend search capabilities through integrations:**
#### Custom Search Connectors
* **CRM Systems**: Search customer data and interactions
* **Knowledge Bases**: Access company documentation and wikis
* **Project Management**: Find content in other project management tools
* **Document Management**: Search enterprise document repositories
#### Search Workflow Automation
* **Automated Content Discovery**: Automatically find and link related content
* **Search-Triggered Actions**: Perform actions based on search queries
* **Content Synchronization**: Keep search indexes updated across platforms
* **Smart Notifications**: Get notified when relevant content is created
## Getting Started with Advanced Search
### Search Setup and Configuration
**Optimize search for your workspace:**
{% stepper %}
{% step %}
#### Review Current Content
Audit your existing projects and content organization.
{% endstep %}
{% step %}
#### Establish Naming Conventions
Create consistent naming standards for projects, tasks, and files.
{% endstep %}
{% step %}
#### Implement Tagging Strategy
Develop a comprehensive tagging system for content categorization.
{% endstep %}
{% step %}
#### Train Your Team
Provide training on advanced search techniques and best practices.
{% endstep %}
{% step %}
#### Monitor and Optimize
Regularly review search analytics and optimize content discoverability.
{% endstep %}
{% endstepper %}
### Search Best Practices Checklist
**Ensure optimal search performance:**
* β
**Use Descriptive Titles**: Create clear, searchable project and task names
* β
**Apply Relevant Tags**: Tag content with appropriate keywords and categories
* β
**Include Rich Descriptions**: Add detailed descriptions with searchable content
* β
**Maintain Consistent Terminology**: Use standard language across similar content
* β
**Regular Content Cleanup**: Archive or delete outdated and irrelevant content
* β
**Train Team Members**: Educate users on effective search techniques
* β
**Monitor Search Performance**: Review search analytics and user feedback
* β
**Optimize for Mobile**: Ensure search works well on mobile devices
{% hint style="info" %}
**Pro Tip**: The most effective search strategies combine good content organization with smart search techniques. Invest time in organizing your workspace structure and training your team on search best practices for maximum productivity gains.
{% endhint %}
# Knowledge Management
Upload, organize, and manage knowledge sources in Taskade to power smarter AI agents, with bulk import, auto-categorization, and the Agents API.
**Transform your scattered information into organized, searchable intelligence that powers smarter AI agents and more effective workflows. Learn how to efficiently upload, organize, and manage knowledge sources for maximum AI performance.**
{% hint style="success" %}
**Smart Knowledge Strategy:** The quality and organization of your knowledge directly impacts AI agent performance. Well-structured knowledge bases can improve response accuracy by 60-80%.
{% endhint %}
***
## Understanding Knowledge Types
### **Supported Knowledge Sources**
| **Source Type** | **Best For** | **Processing** | **AI Benefits** |
| ------------------------ | ---------------------------- | ------------------------- | --------------------------- |
| **π Documents** | Policies, manuals, guides | Text extraction + OCR | Context-aware responses |
| **π Websites** | Latest info, product pages | Live web scraping | Real-time information |
| **π Spreadsheets** | Data, lists, structured info | Data parsing + analysis | Data-driven insights |
| **π₯ Videos** | Training content, demos | Speech-to-text conversion | Video content understanding |
| **π Projects** | Live workspace data | Real-time sync | Current project context |
| **ποΈ File Collections** | Document libraries | Batch processing | Comprehensive knowledge |
### **Knowledge Processing Capabilities**
#### **Automatic Content Enhancement**
```yaml
Processing Features:
Text Extraction: PDFs, Word docs, images with OCR
Language Detection: 100+ languages supported
Content Summarization: Key points and highlights
Semantic Indexing: Meaning-based search optimization
Entity Recognition: Names, dates, locations, concepts
Relationship Mapping: Connections between knowledge pieces
```
***
## Bulk Upload & Organization
### **Bulk Upload Strategies**
#### **Method 1: Drag & Drop Collections**
```
π Knowledge Folder Structure:
βββ π Company Policies/
β βββ employee_handbook.pdf
β βββ code_of_conduct.docx
β βββ benefits_guide.xlsx
βββ π Product Documentation/
β βββ user_manual_v2.pdf
β βββ api_reference.md
β βββ troubleshooting_guide.pdf
βββ π Training Materials/
β βββ onboarding_video.mp4
β βββ sales_training.pptx
β βββ customer_service_scripts.docx
βββ π Live Data Sources/
βββ current_projects.taskade
βββ customer_feedback.csv
βββ inventory_data.xlsx
```
**Bulk Upload Process:**
1. **Prepare folders** with logical organization
2. **Drag entire folder** into knowledge section
3. **AI automatically categorizes** and processes files
4. **Review and adjust** tags and categories
5. **Test knowledge** with sample questions
#### **Method 2: URL Batch Import**
```json
{
"bulkWebImport": {
"sources": [
{
"url": "https://company.com/support/docs",
"crawlDepth": 3,
"includeSubdomains": false,
"excludePatterns": ["/admin/", "/private/"]
},
{
"url": "https://blog.company.com",
"crawlType": "recent_posts",
"timeRange": "last_6_months"
},
{
"url": "https://knowledge.company.com",
"crawlType": "full_site",
"updateFrequency": "weekly"
}
],
"processing": {
"autoTagging": true,
"duplicateDetection": true,
"contentFiltering": "business_relevant"
}
}
}
```
#### **Method 3: API β Add Knowledge to an Agent**
The public REST API adds knowledge to an agent by attaching an existing **project** or **media** file. There is no bulk endpoint in v1 β loop over items to add several.
```bash
# Attach a project to an agent's knowledge base
curl -X POST "https://www.taskade.com/api/v1/agents/{agentId}/knowledge/project" \
-H "Authorization: Bearer your_api_token_placeholder" \
-H "Content-Type: application/json" \
-d '{"projectId": "your_project_id"}'
# Attach an uploaded media file to an agent's knowledge base
curl -X POST "https://www.taskade.com/api/v1/agents/{agentId}/knowledge/media" \
-H "Authorization: Bearer your_api_token_placeholder" \
-H "Content-Type: application/json" \
-d '{"mediaId": "your_media_id"}'
```
### **Smart Organization Systems**
#### **Auto-Categorization Rules**
```yaml
Categorization Rules:
By Content Type:
- "Manual" β Product Documentation
- "Policy" β Company Guidelines
- "Training" β Educational Materials
- "FAQ" β Customer Support
By Department:
- Marketing documents β Marketing Knowledge
- HR files β People Operations
- Engineering docs β Technical Resources
By Recency:
- Last 30 days β Current Information
- 3-12 months β Recent Updates
- 1+ years β Historical Reference
```
#### **Hierarchical Knowledge Structure**
```
π’ Company Knowledge
βββ π Policies & Procedures
β βββ ποΈ Legal & Compliance
β βββ π₯ HR & People Operations
β βββ π Security & Privacy
βββ π¦ Products & Services
β βββ ποΈ Product Catalog
β βββ π User Documentation
β βββ π§ Technical Specifications
βββ π― Sales & Marketing
β βββ π Market Research
β βββ π¨ Brand Guidelines
β βββ π Sales Materials
βββ π οΈ Operations
βββ π Standard Procedures
βββ π Workflow Documentation
βββ π Customer Support Scripts
```
***
## Advanced Knowledge Processing
### **File Processing Automation**
#### **Automated Content Enhancement**
```json
{
"processingPipeline": {
"stages": [
{
"name": "content_extraction",
"actions": [
"extract_text_from_pdfs",
"ocr_for_images",
"speech_to_text_for_videos",
"data_parsing_for_spreadsheets"
]
},
{
"name": "content_enhancement",
"actions": [
"auto_summarization",
"key_phrase_extraction",
"entity_recognition",
"sentiment_analysis"
]
},
{
"name": "organization",
"actions": [
"auto_categorization",
"duplicate_detection",
"relationship_mapping",
"searchability_optimization"
]
}
]
}
}
```
#### **Real-Time Content Updates**
```yaml
Live Sync Configuration:
Project Integration:
- Sync: Real-time updates from connected projects
- Triggers: New tasks, completed items, status changes
- Processing: Incremental knowledge updates
Website Monitoring:
- Frequency: Daily/weekly crawls for updated content
- Change Detection: Modified pages, new articles
- Alerts: Notify when important pages change
Document Versioning:
- Track: Version history for all documents
- Compare: Highlight changes between versions
- Rollback: Restore previous versions if needed
```
### **Quality Control & Optimization**
#### **Knowledge Quality Metrics**
```javascript
{
"qualityMetrics": {
"coverage": {
"totalTopics": 150,
"documentedTopics": 142,
"coverageScore": "94.7%"
},
"freshness": {
"averageAge": "45 days",
"staleContent": "8%",
"lastUpdated": "2024-01-15"
},
"accessibility": {
"searchableContent": "98%",
"duplicates": "2.1%",
"brokenLinks": "0.3%"
},
"usage": {
"mostAccessed": ["product_manual", "faq", "policies"],
"leastAccessed": ["archived_docs", "legacy_info"],
"searchMisses": "5.2%"
}
}
}
```
#### **Automated Quality Checks**
```json
{
"qualityChecks": [
{
"type": "duplicate_detection",
"threshold": 0.85,
"action": "flag_for_review"
},
{
"type": "content_freshness",
"maxAge": "90 days",
"action": "update_reminder"
},
{
"type": "link_validation",
"frequency": "weekly",
"action": "auto_fix_or_report"
},
{
"type": "relevance_scoring",
"minScore": 0.7,
"action": "suggest_archive"
}
]
}
```
***
## AI Agent Training Optimization
### **Knowledge-to-Performance Mapping**
#### **Training Data Quality Impact**
```yaml
Knowledge Quality Factors:
Structure:
- Well-organized: +40% response accuracy
- Clear categorization: +25% search efficiency
- Logical hierarchy: +30% context understanding
Content Quality:
- Current information: +50% accuracy
- Comprehensive coverage: +35% completeness
- Clear writing: +20% comprehension
Metadata Richness:
- Detailed tags: +30% findability
- Context descriptions: +25% relevance
- Relationship mapping: +40% connection insights
```
### **Agent-Specific Knowledge Strategies**
#### **Customer Service Agent**
```yaml
Optimal Knowledge Structure:
Primary Sources:
- FAQ database (comprehensive Q&A)
- Product documentation (technical details)
- Troubleshooting guides (step-by-step solutions)
- Company policies (service guidelines)
Organization Strategy:
- By product line for quick product-specific help
- By issue severity for priority handling
- By customer type for personalized responses
Update Frequency:
- Daily: Product updates, new issues
- Weekly: Policy changes, FAQ additions
- Monthly: Comprehensive review and optimization
```
#### **Sales Agent**
```yaml
Optimal Knowledge Structure:
Primary Sources:
- Product catalogs (features, pricing, specs)
- Sales playbooks (proven techniques, objection handling)
- Market research (competitor analysis, trends)
- Customer case studies (success stories, testimonials)
Organization Strategy:
- By sales stage for pipeline-appropriate content
- By industry for vertical-specific approaches
- By customer size for tailored solutions
Performance Tracking:
- Conversion rates by knowledge source
- Most effective sales materials
- Knowledge gaps causing lost deals
```
#### **Content Creation Agent**
```yaml
Optimal Knowledge Structure:
Primary Sources:
- Brand guidelines (voice, tone, visual standards)
- Content templates (proven formats and structures)
- Performance data (what content works best)
- Industry insights (trends, audience preferences)
Creative Enhancement:
- Example library (high-performing content)
- Style guides (writing standards by content type)
- Visual assets (logos, images, design elements)
- Competitor analysis (market positioning insights)
```
***
## Knowledge Analytics & Insights
### **Usage Analytics Dashboard**
#### **Knowledge Performance Metrics**
```javascript
{
"knowledgeAnalytics": {
"searchPatterns": {
"topQueries": [
{"query": "password reset", "frequency": 1250, "success_rate": "94%"},
{"query": "pricing plans", "frequency": 890, "success_rate": "88%"},
{"query": "integration setup", "frequency": 670, "success_rate": "76%"}
],
"failedSearches": {
"count": 45,
"common_gaps": ["mobile app issues", "advanced reporting", "API limits"]
}
},
"contentEffectiveness": {
"mostHelpful": [
{"document": "setup_guide.pdf", "helpfulness": "96%", "usage": 2300},
{"document": "api_reference.md", "helpfulness": "91%", "usage": 1800}
],
"needsImprovement": [
{"document": "legacy_docs.pdf", "helpfulness": "45%", "issue": "outdated"}
]
}
}
}
```
### **Predictive Knowledge Management**
#### **Content Recommendations**
```yaml
AI-Powered Suggestions:
Missing Knowledge:
- Analyze failed searches to identify gaps
- Predict future information needs based on trends
- Suggest content creation priorities
Optimization Opportunities:
- Identify redundant or conflicting information
- Recommend content consolidation
- Suggest better organization structures
Update Priorities:
- Flag outdated content based on usage patterns
- Predict when information will become stale
- Recommend refresh schedules
```
***
## Technical Implementation
### **Knowledge API Management**
#### **Agent Knowledge API**
The public REST API manages agent knowledge by attaching or removing **projects** and **media** per agent. v1 has no bulk-upload, bulk-update, or knowledge-search endpoint β iterate to add items, and query knowledge by prompting the agent.
```bash
# Add a project to an agent's knowledge base
curl -X POST "https://www.taskade.com/api/v1/agents/{agentId}/knowledge/project" \
-H "Authorization: Bearer your_api_token_placeholder" \
-H "Content-Type: application/json" \
-d '{"projectId": "your_project_id"}'
# Add a media file (upload it via the Media API first)
curl -X POST "https://www.taskade.com/api/v1/agents/{agentId}/knowledge/media" \
-H "Authorization: Bearer your_api_token_placeholder" \
-H "Content-Type: application/json" \
-d '{"mediaId": "your_media_id"}'
# Remove a project from an agent's knowledge base
curl -X DELETE "https://www.taskade.com/api/v1/agents/{agentId}/knowledge/project/{projectId}" \
-H "Authorization: Bearer your_api_token_placeholder"
```
See the full [Agents API reference](/developers/comprehensive-api-guide/agents).
### **Integration Patterns**
#### **CMS Integration**
```javascript
// Sync with content management systems
const syncCMS = async (agentId, token) => {
const cmsContent = await fetchFromCMS();
// No bulk endpoint exists in v1 β attach each imported project to the agent:
for (const projectId of cmsContent.projectIds) {
await fetch(`https://www.taskade.com/api/v1/agents/${agentId}/knowledge/project`, {
method: "POST",
headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
body: JSON.stringify({ projectId }),
});
}
const processedContent = cmsContent.projectIds;
return processedContent;
};
```
#### **Real-Time Updates**
Taskade does not expose a public WebSocket API. Knowledge changes take effect immediately when you add or remove items via the REST endpoints above. To react to changes programmatically, use an automation trigger (for example, **File Added to Media**) rather than a live socket.
***
## Best Practices & Strategies
### **Knowledge Organization Principles**
#### **The 3-Layer Structure**
```yaml
Layer 1 - Core Knowledge (80% of queries):
- Essential product information
- Common procedures and policies
- Frequently asked questions
Layer 2 - Detailed Reference (15% of queries):
- Technical documentation
- Advanced features and configurations
- Troubleshooting guides
Layer 3 - Specialized Content (5% of queries):
- Edge cases and rare scenarios
- Legacy information
- Highly technical specifications
```
#### **Maintenance Strategies**
**Monthly Knowledge Audit:**
```yaml
Review Process:
Week 1: Usage Analytics Review
- Identify most/least accessed content
- Review search success rates
- Analyze user feedback
Week 2: Content Quality Check
- Update outdated information
- Fix broken links and references
- Consolidate duplicate content
Week 3: Gap Analysis
- Identify missing knowledge areas
- Plan new content creation
- Review competitor knowledge bases
Week 4: Optimization Implementation
- Reorganize based on usage patterns
- Update tags and categories
- Improve search functionality
```
### **Team Collaboration on Knowledge**
#### **Role-Based Knowledge Management**
```yaml
Team Responsibilities:
Knowledge Owners:
- Subject matter experts for specific domains
- Responsible for content accuracy and updates
- Primary reviewers for their knowledge areas
Content Contributors:
- Create and submit new knowledge items
- Report outdated or incorrect information
- Suggest improvements and additions
Knowledge Administrators:
- Manage overall knowledge structure
- Coordinate updates and reviews
- Monitor usage analytics and optimization
```
***
## Success Stories & ROI
### **Knowledge Management Impact**
#### **Customer Support Transformation**
```yaml
Before Knowledge Management:
- Average response time: 4.5 hours
- First-contact resolution: 62%
- Agent confidence score: 6.8/10
- Training time for new agents: 3 weeks
After Knowledge Management:
- Average response time: 45 minutes (-83%)
- First-contact resolution: 89% (+44%)
- Agent confidence score: 9.1/10 (+34%)
- Training time for new agents: 1 week (-67%)
ROI Impact:
- 60% reduction in support costs
- 40% increase in customer satisfaction
- 75% faster agent onboarding
- 300% improvement in knowledge utilization
```
#### **Sales Enablement Success**
```yaml
Sales Team Results:
Knowledge Implementation:
- Centralized sales materials and playbooks
- Real-time competitor intelligence
- Customer case study library
- Product information automation
Performance Improvements:
- Sales cycle length: -35%
- Win rate: +28%
- Quote accuracy: +45%
- New rep ramp time: -50%
Business Impact:
- $2.3M additional revenue from faster sales cycles
- 40% reduction in proposal preparation time
- 90% of reps exceeding quota (vs 65% before)
```
***
## Getting Started Checklist
### **Week 1: Foundation Setup**
* [ ] Audit existing knowledge sources
* [ ] Define knowledge categories and structure
* [ ] Set up bulk upload processes
* [ ] Configure automated processing rules
### **Week 2: Content Migration**
* [ ] Bulk upload core documents
* [ ] Connect live data sources (projects, websites)
* [ ] Set up automated content updates
* [ ] Test knowledge search and retrieval
### **Week 3: AI Agent Training**
* [ ] Connect knowledge to relevant AI agents
* [ ] Test agent responses with knowledge base
* [ ] Refine knowledge organization based on performance
* [ ] Set up knowledge analytics tracking
### **Week 4: Optimization & Scaling**
* [ ] Review usage analytics and optimize
* [ ] Set up maintenance schedules and workflows
* [ ] Train team on knowledge management best practices
* [ ] Plan ongoing content expansion strategy
***
**π§ Ready to transform your scattered information into AI-powered intelligence?** Start with organizing your most frequently needed documents, then expand to comprehensive knowledge coverage.
*For advanced AI agent training techniques, see our* [*AI Agents Guide*](/ai-features/ai-features/ai-agents-getting-started)*. For automation of knowledge processes, check out* [*Advanced Automation Actions*](/automations/automation/advanced-actions)*.*
*To build programmatic knowledge workflows like the bulk upload and search examples above, see the* [*Developer Hub*](/developers/developer-home) *and the* [*REST API Guide*](/developers/comprehensive-api-guide)*.*
# Mobile
Build mobile-first Taskade Genesis apps and workflows: iOS/Android apps, PWA, offline sync, Quick Add widget, voice, and responsive design across devices.
**Master Taskade's mobile-first features and create apps that work beautifully across all devices. From responsive Taskade Genesis apps to native mobile workflows, ensure your users have a seamless experience whether they're on desktop, tablet, or phone.**
{% hint style="success" %}
**Mobile-First Approach:** Taskade is built for mobile from the ground up. Mobile users get strong performance, smooth interactions, and collaboration features that make working on a phone or tablet feel as capable as desktop.
{% endhint %}
***
## Mobile App Ecosystem
### **Native Applications**
#### **iOS & Android Apps**
* **Full feature parity** with desktop versions
* **Offline capabilities** for viewing and editing projects
* **Push notifications** for real-time updates and alerts
* **Biometric authentication** for secure, fast access
* **Camera integration** for document scanning and photo uploads
* **Quick Add Widget** for instant task creation from home screen
* **Natural language processing** for smart date and time recognition
* **Voice input support** for hands-free task creation
* **Superior mobile experience** with enhanced performance and usability
* **Enhanced collaboration** features for better team coordination
* **Improved search capabilities** for finding content quickly on mobile
* **Mobile Ribbon Enhancement** for better navigation and interaction on mobile devices
* **Desktop Ribbon functionality** now available on mobile platforms
#### **Progressive Web App (PWA)**
* **Install directly from browser** - no app store required
* **Offline functionality** for critical workflows
* **Native-like experience** on any device
* **Automatic updates** without manual app store downloads
### **Mobile Paywall Integration**
Seamless upgrade experiences designed specifically for mobile users:
#### **Native Mobile Paywall**
* **In-App Purchase Flow** - Direct integration with App Store and Google Play billing
* **Contextual Upgrades** - Upgrade prompts triggered by feature usage
* **Seamless Experience** - No app switching or browser redirects
* **Restored Purchases** - Automatic restoration of previous purchases
* **Subscription Management** - Easy plan changes and cancellations
#### **Progressive Web App Paywall**
* **Browser-Based Checkout** - Optimized mobile web payment experience
* **Credit Card Integration** - Secure payment processing for all devices
* **Plan Comparison** - Mobile-friendly pricing display
* **Instant Activation** - Immediate feature access after purchase
### **Improved Paywall Logic**
**Latest Enhancement:** Smarter upgrade prompts and feature access management for mobile users.
**Key Improvements:**
* **Contextual Upgrade Prompts** - Intelligent suggestions based on user behavior and usage patterns
* **Feature Access Management** - Seamless transitions between free and premium features
* **Personalized Recommendations** - Upgrade suggestions tailored to individual user needs
* **Reduced Friction** - Smoother upgrade experience with clear value propositions
### **Enhanced Breadcrumb Navigation**
**Latest Enhancement:** Improved breadcrumb navigation with tooltips for better user experience across mobile devices.
**Navigation Improvements:**
* **Contextual Breadcrumbs** - Clear navigation path showing your current location
* **Interactive Tooltips** - Helpful hints when hovering over navigation elements
* **Deep Navigation Clarity** - Easy understanding of navigation hierarchy
* **Touch-Optimized Controls** - Larger touch targets for better mobile interaction
### **Quick Add Widget: Instant Productivity**
The Quick Add widget is a powerful companion tool that lives on your device's home screen, enabling instant task creation without opening the main app.
#### **Widget Features**
* **Home screen access** - Add tasks instantly from your device's home screen
* **Smart date recognition** - Natural language processing for dates and times
* **Project selection** - Quick access to your most-used projects
* **Voice input** - Speak your tasks for hands-free creation
* **Offline support** - Tasks sync automatically when connection is restored
#### **Setting Up Quick Add**
**iOS Setup:**
1. Long-press on home screen to enter edit mode
2. Tap the "+" button to add widgets
3. Search for "Taskade" and select Quick Add widget
4. Choose widget size and placement
5. Configure default project and settings
**Android Setup:**
1. Long-press on home screen
2. Select "Widgets" from the menu
3. Find and drag Taskade Quick Add widget
4. Resize and position as needed
5. Tap to configure default settings
#### **Smart Date Suggestions**
The widget uses natural language processing to automatically detect dates and times:
* **"Meeting tomorrow at 3pm"** β Sets due date for tomorrow 3:00 PM
* **"Call client next Monday"** β Sets due date for next Monday
* **"Review report by Friday"** β Sets due date for this Friday
* **"Dentist appointment in 2 weeks"** β Sets due date 14 days from now
### **Cross-Platform Synchronization**
```yaml
Real-time Sync Features:
- Instant updates across all devices
- Conflict-free collaborative editing
- Offline changes sync automatically when reconnected
- Cross-device cursor tracking and live collaboration
- Background sync maintains data consistency
```
***
## Responsive Design Principles
### **Adaptive Interface Design**
#### **Screen Size Optimization**
```css
/* Mobile breakpoints automatically handled by Taskade */
Mobile (320-768px):
- Single column layouts
- Touch-friendly button sizes (44px minimum)
- Simplified navigation patterns
- Optimized text sizes (16px+ to prevent zoom)
Tablet (768-1024px):
- Two-column layouts where appropriate
- Expanded touch targets
- Enhanced gesture support
- Side panel navigation options
Desktop (1024px+):
- Multi-column layouts
- Keyboard shortcuts prominently displayed
- Advanced features and dense information display
```
### **Touch-First Interaction Design**
#### **Gesture Support**
* **Swipe actions** for quick navigation
* **Long press** for context menus and advanced options
* **Pull to refresh** for real-time content updates
* **Drag and drop** for intuitive task and project organization
#### **Mobile-Optimized Controls**
```yaml
Touch Interface Elements:
Buttons:
- Minimum 44px touch targets
- Clear visual feedback on tap
- Appropriate spacing between interactive elements
Forms:
- Large, easy-to-tap input fields
- Smart keyboard types (email, number, URL)
- Auto-complete and smart suggestions
- Clear error messaging and validation
Navigation:
- Bottom tab bars for thumb accessibility
- Hamburger menus for secondary navigation
- Breadcrumbs for deep navigation clarity
```
***
## Mobile-Optimized Genesis Apps
### **Creating Mobile-First Apps**
#### **Mobile-Optimized Prompts**
```
Good Mobile App Prompt:
"Create a restaurant feedback app that works perfectly on phones:
- Large, easy-to-tap star ratings
- Simple text input with auto-resize
- One-handed photo upload with camera integration
- Big submit button that's thumb-accessible
- Create a Thank you screen that fits phone screens
- Automatic keyboard optimization for each field type"
```
#### **Responsive Layout Strategies**
```yaml
Mobile Layout Best Practices:
Form Design:
- Single column layouts
- Logical tab order for keyboard users
- Minimal scrolling required
- Clear progress indicators
Content Display:
- Card-based layouts for easy scanning
- Generous white space for readability
- Hierarchical typography with clear headings
- Collapsible sections for complex content
Navigation:
- Bottom navigation for primary actions
- Sticky headers with essential controls
- Contextual action buttons
- Clear back/forward navigation paths
```
### **Mobile Performance Optimization**
#### **Fast Loading & Smooth Interactions**
```javascript
// Mobile optimization techniques automatically applied:
{
"mobileOptimizations": {
"lazyLoading": {
"images": "Load only when in viewport",
"forms": "Progressive loading for multi-step forms",
"content": "Prioritize above-the-fold content"
},
"caching": {
"appShell": "Instant loading for repeat visits",
"data": "Smart caching for offline functionality",
"media": "Optimized image sizes for device resolution"
},
"networkAdaptation": {
"slowConnections": "Reduce data usage and simplify interfaces",
"offlineMode": "Core functionality available without internet",
"progressiveDegradation": "Features degrade gracefully on slower devices"
}
}
}
```
#### **Battery & Data Conservation**
* **Efficient background sync** to minimize battery drain
* **Compressed data transfer** for slower connections
* **Smart update scheduling** during optimal network conditions
* **Reduced animation** on lower-powered devices
***
## Project Views for Mobile
### **Mobile-Optimized View Types**
#### **Action View - Mobile-First Design**
```yaml
Action View Features:
- Designed specifically for mobile workflow
- Quick task capture with voice-to-text
- Swipe gestures for task completion
- Large, thumb-friendly checkboxes
- Minimal interface clutter
- Perfect for on-the-go task management
```
#### **Responsive Board View**
```yaml
Mobile Board Adaptations:
- Horizontal scrolling for swim lanes
- Card stacking for narrow screens
- Drag indicators for touch clarity
- Simplified card content for readability
- Quick actions via long press
```
#### **Calendar View Mobile Enhancements**
```yaml
Mobile Calendar Features:
- Month/week/day views optimized for small screens
- Touch-friendly date selection
- Quick event creation with smart defaults
- Gesture-based navigation between time periods
- Integration with device calendar apps
```
### **View Switching on Mobile**
#### **Smart View Recommendations**
```javascript
// Automatic view recommendations based on device
{
"deviceOptimization": {
"phone": {
"recommended": ["Action", "List", "Calendar"],
"avoid": ["Org Chart", "Gantt"],
"reason": "Better for single-column, sequential interaction"
},
"tablet": {
"recommended": ["Board", "Table", "Mind Map"],
"reason": "Larger screen enables multi-column layouts"
},
"desktop": {
"recommended": "All views fully supported",
"reason": "Full screen real estate available"
}
}
}
```
***
## Mobile Workflows & Automations
#### **Time-Based Mobile Context**
```json
{
"contextualAutomation": {
"trigger": {
"type": "schedule.time",
"time": "09:00",
"device": "mobile"
},
"actions": [
{
"type": "notification.morning_briefing",
"content": "Today's priorities and calendar overview"
},
{
"type": "project.prioritize",
"criteria": "mobile_accessible_tasks"
}
]
}
}
```
### **Voice & Camera Integration**
#### **Voice-to-Text Capabilities**
```yaml
Voice Features:
Task Creation:
- "Add task: Call client about project update"
- "Create meeting: Team sync tomorrow 2 PM"
- "Note: Great idea during lunch meeting"
Dictation Support:
- Long-form content creation
- Meeting notes and summaries
- Comment and feedback capture
```
***
## Mobile App Development Best Practices
### **Mobile-First Genesis Design**
#### **Design Principles**
```yaml
Mobile-First Checklist:
User Interface:
- Thumb-friendly navigation zones
- High contrast for outdoor visibility
- Larger text for readability
- Simplified information architecture
User Experience:
- Single-purpose screens
- Minimal cognitive load
- Clear visual hierarchy
- Obvious call-to-action buttons
Performance:
- Fast initial load (under 3 seconds)
- Smooth 60fps animations
- Efficient memory usage
- Battery-conscious background processing
```
#### **Progressive Enhancement Strategy**
```javascript
// Feature detection and progressive enhancement
{
"progressiveEnhancement": {
"coreFeatures": {
"available": "On all devices and connections",
"includes": ["basic forms", "content viewing", "simple navigation"]
},
"enhancedFeatures": {
"requiresCapabilities": ["faster processor", "good connection", "modern browser"],
"includes": ["real-time collaboration", "advanced animations", "offline sync"]
},
"premiumFeatures": {
"requiresOptimalConditions": ["latest devices", "high-speed connection"],
"includes": ["video integration", "advanced AI features", "complex visualizations"]
}
}
}
```
### **Testing Across Devices**
#### **Device Testing Strategy**
```yaml
Testing Matrix:
Devices:
- iPhone SE (small screen baseline)
- iPhone 14 Pro (current iOS standard)
- Pixel 9 Pro (Android flagship)
- iPad Air (tablet experience)
- Various Android tablets
Connection Types:
- 5G (optimal experience)
- 4G LTE (standard experience)
- 3G (degraded but functional)
Operating Systems:
- iOS 15+ (minimum supported)
- Android 10+ (minimum supported)
- Various browsers and versions
```
***
## Mobile Analytics & Optimization
### **Mobile-Specific Metrics**
#### **Performance Tracking**
```javascript
{
"mobileMetrics": {
"performanceKPIs": {
"loadTime": "< 3 seconds for initial render",
"timeToInteractive": "< 5 seconds for full functionality",
"frameRate": "60fps for smooth animations",
"memoryUsage": "< 100MB for optimal performance"
},
"usageAnalytics": {
"screenTime": "Average session duration by device type",
"featureUsage": "Most/least used features on mobile",
"dropOffPoints": "Where users abandon mobile workflows",
"conversionRates": "Task completion rates mobile vs desktop"
},
"userExperience": {
"touchAccuracy": "Success rate for touch interactions",
"navigationEfficiency": "Steps to complete common tasks",
"errorRates": "Frequency of user errors on mobile",
"satisfactionScores": "User feedback on mobile experience"
}
}
}
```
### **Continuous Mobile Optimization**
#### **A/B Testing for Mobile**
```yaml
Mobile Optimization Tests:
Interface Elements:
- Button sizes (44px vs 48px vs 52px)
- Navigation patterns (bottom tabs vs hamburger)
- Color schemes (high contrast vs brand colors)
Workflow Improvements:
- Form length (single page vs multi-step)
- Input methods (typing vs voice vs selection)
- Confirmation patterns (immediate vs delayed feedback)
Content Strategy:
- Information density (minimal vs comprehensive)
- Media usage (images vs icons vs text-only)
- Messaging tone (casual vs professional)
```
***
## Technical Implementation
### **Mobile-Specific APIs**
#### **Device Capability Detection**
```javascript
// Automatic mobile optimization based on device capabilities
const deviceCapabilities = {
screen: {
size: window.innerWidth < 768 ? "mobile" : "desktop",
density: window.devicePixelRatio,
orientation: screen.orientation?.type,
},
performance: {
connection: navigator.connection?.effectiveType,
memory: navigator.deviceMemory,
cores: navigator.hardwareConcurrency,
},
features: {
touchSupport: "ontouchstart" in window,
geolocation: "geolocation" in navigator,
camera: "mediaDevices" in navigator,
voiceRecognition: "webkitSpeechRecognition" in window,
},
};
```
#### **Service Worker for Offline Support**
```javascript
// Offline functionality for mobile apps
self.addEventListener("fetch", (event) => {
if (event.request.url.includes("/api/")) {
event.respondWith(
caches.match(event.request).then((response) => {
// Return cached version or fetch from network
return response || fetch(event.request);
})
);
}
});
```
### **Mobile App Embedding**
#### **Responsive Iframe Integration**
```html
```
***
## Mobile Success Stories
### **Real-World Mobile Implementations**
#### **Field Service Management App**
```yaml
Use Case: Technician workflow management
Mobile Features:
- Voice notes for hands-free reporting
- Push notifications for urgent jobs
Results:
- 45% faster job completion times
- 60% reduction in paperwork
- 90% technician adoption rate
- 25% improvement in customer satisfaction
```
#### **Event Check-in System**
```yaml
Use Case: Conference registration and networking
Mobile Features:
- Real-time capacity monitoring
- Push notifications for session alerts
Results:
- 50% increase in networking connections
- Zero paper waste elimination
```
#### **Restaurant Ordering Platform**
```yaml
Use Case: Mobile-first food ordering
Mobile Features:
- Touch-optimized menu navigation
- Visual dish selection with photos
- Apple Pay/Google Pay integration
- Real-time order tracking
Results:
- 120% increase in mobile orders
- 35% higher average order value
- 90% customer satisfaction score
- 40% reduction in order errors
```
***
## **Advanced Mobile Features**
### **Mobile Widget Ecosystem**
| **Widget Type** | **Functionality** | **Business Use Case** |
| ------------------------- | ----------------------------------- | ------------------------------- |
| **Quick Add Widget** | Add tasks with NLP date recognition | Capture ideas instantly |
| **Agent Chat Widget** | Direct agent communication | Get answers without opening app |
| **Project Status Widget** | Live project progress display | Monitor KPIs at a glance |
| **Team Activity Widget** | Real-time team updates | Stay connected to team progress |
| **AI Assistant Widget** | Enhanced AI assistance on mobile | Smart help anywhere |
| **Collaboration Widget** | Improved team coordination | Better mobile teamwork |
| **Mobile Paywall Widget** | Seamless upgrade flow on mobile | Easy premium feature access |
### **Mobile Automation Triggers**
| **Trigger** | **Mobile Advantage** | **Example Use Case** |
| ----------------- | --------------------- | -------------------------------- |
| **Time-Based** | Background processing | Daily standup reminders |
| **Photo Upload** | Camera integration | Auto-categorize expense receipts |
| **Voice Command** | Hands-free operation | Create tasks while driving |
### **Offline-First Architecture**
**Smart Sync Technology:**
* **Conflict Resolution** - Intelligent merging of offline changes
* **Priority Queuing** - Critical updates sync first
* **Bandwidth Optimization** - Compress data for mobile networks
* **Background Sync** - Updates happen seamlessly
**Offline Capabilities:**
* **Full Project Access** - Work on cached projects
* **Agent Conversations** - Continue chats offline
* **Task Management** - Create, edit, complete tasks
* **Voice Notes** - Record ideas for later processing
### **Mobile Security & Privacy**
| **Security Feature** | **Protection Level** | **Business Benefit** |
| ------------------------ | --------------------- | -------------------- |
| **App-Level Encryption** | End-to-end protection | Compliance ready |
| **Remote Wipe** | Enterprise control | Protect lost devices |
| **VPN Integration** | Network security | Secure remote access |
### **Mobile Performance Optimization**
**Battery Efficiency:**
* **Smart Background Processing** - Minimize battery drain
* **Adaptive Refresh Rates** - Reduce unnecessary updates
* **Power-Aware Sync** - Sync less frequently on low battery
* **Dark Mode Optimization** - Reduce OLED power consumption
**Memory Management:**
* **Intelligent Caching** - Keep frequently used data in memory
* **Progressive Loading** - Load content as needed
* **Memory Cleanup** - Automatic garbage collection
* **Resource Optimization** - Efficient image and data handling
## Living Systems Mobile Capabilities
### **Mobile Workspace DNA**
**Living Memory on Mobile:**
* **Adaptive Data Structures** - Project layouts that optimize for mobile screens
* **Intelligent Caching** - Smart data storage that learns your mobile usage patterns
* **Contextual Sync** - Sync priorities based on your current mobile context
* **Offline Intelligence** - AI agents continue learning even when offline
**Living Intelligence on Mobile:**
* **EVE Mobile Companion** - Your AI assistant optimized for mobile interactions
* **Voice-First AI** - Natural voice conversations with intelligent agents
* **Contextual Suggestions** - AI that understands your mobile environment and needs
* **Predictive Assistance** - Proactive help based on your mobile behavior patterns
**Living Motion on Mobile:**
* **Mobile-Optimized Automations** - Workflows designed for mobile triggers and actions
* **Location-Aware Actions** - Automations that respond to your physical location
* **Camera-Triggered Workflows** - Automations activated by photo or video capture
* **Touch-Optimized Controls** - Gestures and interactions designed for mobile use
### **Mobile Living System Examples**
#### **Field Service Living System**
```
Mobile Capabilities:
βββ GPS location tracking with intelligent routing
βββ Camera integration for photo documentation
βββ Voice notes for hands-free updates
βββ Offline form completion with smart sync
βββ Predictive scheduling based on historical patterns
```
#### **Sales Mobile Living System**
```
Mobile Features:
βββ Contact scanning with instant CRM integration
βββ Voice-to-text meeting notes with AI summarization
βββ Location-based lead suggestions
βββ Mobile-optimized dashboards with touch gestures
βββ Predictive follow-up reminders based on engagement patterns
```
#### **Healthcare Mobile Living System**
```
Mobile Intelligence:
βββ HIPAA-compliant voice transcription
βββ Medication scanning with interaction checking
βββ Patient vitals with trend analysis
βββ Emergency protocols with location awareness
βββ Care coordination with real-time updates
```
### **Mobile Living System Performance**
**Adaptive Performance:**
* **Context-Aware Loading** - Faster loading based on your typical mobile usage
* **Predictive Prefetching** - Anticipate data needs based on behavior patterns
* **Smart Compression** - Optimize data transfer for current network conditions
* **Battery-Aware Processing** - Adjust performance based on battery level
**Living Mobile Optimization:**
* **Usage Pattern Learning** - Apps that adapt to your mobile workflow habits
* **Network Condition Adaptation** - Performance optimization for varying connectivity
* **Device Capability Detection** - Automatic feature adjustment for device capabilities
* **Continuous Performance Improvement** - Systems that get faster with regular use
### **Mobile Living Ecosystem Integration**
**Cross-App Intelligence:**
* **Workspace DNA Sharing** - Living systems that communicate across apps
* **Unified Mobile Experience** - Consistent behavior across all Taskade mobile apps
* **Context Preservation** - Seamless transitions between mobile and desktop experiences
* **Living Data Continuity** - Information flows intelligently between all your devices
**Third-Party Mobile Integration:**
* **Mobile App Connectors** - Living integrations with mobile-native services
* **Wearable Device Support** - Integration with smartwatches and fitness trackers
* **IoT Device Integration** - Connect with mobile-connected smart devices
* **Mobile Payment Systems** - Seamless integration with mobile payment platforms
***
**π± Ready to create mobile-optimized experiences?** Start with mobile-first Genesis prompts and progressive enhancement strategies to ensure your apps work beautifully on every device.
*For more mobile development insights, explore our* [*Genesis Space Apps Guide*](/taskade-genesis/space-apps-guide) *and* [*Advanced Automation*](/automations/automation/advanced-actions) *for location-based workflows.*
# Community & Sharing
Share, publish, and clone Taskade apps and templates β collaborate with your team or ship to the community with public links and custom domains.
**Turn your brilliant Taskade Genesis app into something that helps business owners everywhere. Share what you've built, discover amazing solutions from others, and copy complete apps with just one click.**
{% hint style="success" %}
**What you can do here.** Publish your Taskade Genesis apps to the community, let others fork them in one click, and monetize premium apps with Stripe checkout.
{% endhint %}
***
## **Publish and Share Your Apps**
Share your Genesis creations with the world through publishing and cloning capabilities.
### **Publishing Apps**
Make your apps available to anyone with a link, creating public or private access points for your solutions.
**Publishing Benefits:**
* **Direct Access**: Users can interact with your app through a dedicated URL
* **No Installation Required**: Works immediately in any browser
* **Version Control**: Update your published app while maintaining the same link
* **Monetization Ready**: Sell paid apps with one-time Stripe checkout
**Publishing Options:**
* **Public Apps**: Discoverable and accessible to anyone with the link
* **Private Apps**: Require specific permissions or passwords for access
### **App Visibility Settings**
Choose how people access your published app:
**Public Apps:**
* Anyone with the link can access and use your app
* No authentication required
* Ideal for marketing, demonstrations, or free tools
**Private Apps:**
* Require user authentication to access
* Control who can use your app
* Suitable for client portals or internal tools
### **Unpublishing Apps**
You can always unpublish your app if needed:
1. **Open your Genesis app** in your workspace
2. **Click the Publish dropdown** in the top toolbar
3. **Select "Unpublish"**
4. **Confirm the action**
**Note:** Unpublishing immediately removes public access, but the URL becomes inactive. Users who bookmarked the link will lose access.
### **Enabling Cloning (Forking)**
Allow others to create complete copies of your published app in their own workspaces. (When others copy your public app it's called **forking**; **cloning** also refers to duplicating your own app inside your workspace β the toggle below covers both.)
**Cloning Features:**
* **One-Click Duplication**: Users can clone your entire app with a single click
* **Complete Fidelity**: All projects, agents, automations, and media files are copied
* **Independent Operation**: Cloned apps function completely independently
* **Customization Freedom**: Users can modify cloned apps without affecting the original
### **When to Use Templates vs. Cloning**
**Use Templates When:**
* You want to provide starting points for customization
* Users need to adapt the app significantly for their use case
* You're sharing incomplete or example workflows
**Use Cloning When:**
* Your app is a complete, working solution
* Users should have immediate functionality without setup
* You want to share proven, production-ready workflows
## App Forking
The most powerful way to learn and build is by starting with working solutions. Genesis now lets you fork (copy) any community app with complete fidelity.
### **What is App Forking?**
Forking creates a complete, independent copy of a Genesis app in your workspace. Unlike simple templates, forking gives you:
* **Complete Workspace Clone**: All projects, agents, automations, and media files
* **Working Integrations**: Connections and workflows that function immediately
* **Full Customization Rights**: Modify, rebrand, and extend however you want
* **Independent Evolution**: Your forked app develops separately from the original
### **One-Click Complete Duplication**
When you fork a Genesis app, you get:
| What Gets Copied | Details |
| ---------------------- | ----------------------------------------------------- |
| **π¨ App Interface** | Complete layout, styling, and user experience |
| **π Projects & Data** | All project structures with example data |
| **π€ AI Agents** | Trained agents with their knowledge and personalities |
| **β‘ Automations** | Working workflows and integrations |
| **π Media Files** | Images, documents, and assets |
| **π§ Configuration** | Settings, permissions, and customizations |
### **Professional Use Cases**
**For Agencies:**
* Fork client portal templates and customize for each client
* Start with proven solutions instead of building from scratch
* Maintain consistent quality across client projects
**For Entrepreneurs:**
* Copy successful business models and adapt to your market
* Learn from working examples of complex workflows
* Accelerate time-to-market with proven foundations
**For Teams:**
* Share internal tools across departments
* Standardize processes with working templates
* Enable non-technical team members to deploy solutions
***
## Sharing Your App with Everyone
### What Happens When You Share?
When you share your Genesis app with the community, it goes into a public library where other business owners can find it, try it out, and copy it for their own use. You can explore the [Taskade community](https://www.taskade.com/community) to see the shared apps, agents, and templates other builders have published. Think of it like sharing a great recipeβyou help others while showing off your skills!
### When to Share with Community
**Perfect for:**
* Universal business solutions (CRM templates, feedback systems, inventory trackers)
* Educational examples and tutorials
* Industry-specific tools that benefit many organizations
* Showcasing your development skills and creativity
* Building your professional reputation
**Keep Private for:**
* Client-specific solutions with proprietary workflows
* Apps containing sensitive business data or processes
* Highly customized solutions that won't transfer well
* Work-in-progress apps that aren't ready for public use
***
## **Professional Publishing with Paywalls**
Transform your Genesis apps into revenue-generating solutions with professional publishing features.
### **Monetize Your Expertise**
Create premium Taskade Genesis apps that users pay for: set a **one-time price** in your app's Publish settings, and buyers pay via **Stripe** to receive their own private copy of the app. See [Paid Apps](/community-and-sharing/community-and-sharing/publish-and-clone#paid-apps) for the full flow.
### **Perfect for:**
**Consultants & Agencies:**
* Client assessment tools and calculators
* Industry-specific templates and workflows
* Diagnostic and analysis applications
**SaaS Entrepreneurs:**
* Niche business tools and utilities
* Specialized dashboards and reporting
* Process automation solutions
**Content Creators:**
* Educational tools and courses
* Interactive guides and tutorials
* Community management platforms
### **Professional Features**
| Feature | Benefit |
| ------------------------- | ------------------------------------------------ |
| **π Access Control** | Buyers receive their own private copy of the app |
| **π Analytics** | Built-in metrics on views, likes, and installs |
| **π³ Payment Processing** | Payments handled by Stripe |
| **π¨ Custom Branding** | Your logo, colors, and domain |
***
## **Embeddable Public AI Agents**
Share your AI expertise by embedding trained agents directly into websites, documentation, or any web page.
### **Agents Anywhere**
The agent **Share** panel includes an embed snippet builder β copy a ready-made snippet (inline iframe or floating chat widget) and customize the **launcher icon** and background to match your site. The generated iframe points at your agent's public URL:
```html
```
Copy the snippet from the Share panel rather than hand-writing it β the builder fills in the correct URL for your agent (including custom domains).
### **Use Cases**
**Customer Support:**
* Embed support agents on your website
* Provide 24/7 assistance with your product knowledge
* Handle common questions automatically
**Lead Generation:**
* Qualification agents that assess potential clients
* Interactive consultations that capture contact info
* Product recommendation engines
**Education & Training:**
* Subject matter experts embedded in courses
* Interactive tutors for complex topics
* Assessment and feedback systems
### **Professional Integration**
* **Seamless Branding**: Agents match your website's design
* **Custom Domains**: Host agents on your own domain
* **Analytics Tracking**: Monitor conversations and effectiveness
* **Lead Capture**: Automatically collect user information
***
## How to Publish to Community
### Step 1: Prepare Your App
Before sharing, ensure your app is ready for public use:
**Content Review:**
* Remove any sensitive data, API keys, or personal information
* Use generic example data that demonstrates functionality
* Ensure all text is professional and helpful
* Test all features work correctly
**Documentation:**
* Add clear descriptions of what the app does
* Include setup instructions if integrations are needed
* Provide example use cases and benefits
* Consider adding a brief "how it works" explanation
### Step 2: Publish to Community
1. **Open your Genesis app** in your workspace
2. **Click the Publish dropdown** in the top toolbar
3. **Select "Share with Community"**
4. **Fill out the community listing:**
* **App Title**: Clear, descriptive name
* **Category**: Choose appropriate business category
* **Description**: Explain what it does and who it helps
* **Tags**: Add searchable keywords
* **Screenshot**: Upload a preview image
5. **Review and Publish**: Your app goes live immediately
### Step 3: Manage Your Community App
**Track Performance:**
* View fork count and usage metrics
* See user feedback and ratings
* Monitor which features are most popular
**Keep It Updated:**
* Regular updates improve discoverability
* Fix issues reported by community users
* Add new features based on feedback
***
## Forking Apps from Community
### What is App Forking?
Forking creates a complete, independent copy of a Genesis app in your workspace. You get everything: projects, AI agents, automations, media files, and configurationsβall ready to use and customize.
### Finding Apps to Fork
**Browse the Community Marketplace:**
* **By Category**: Business tools, customer service, e-commerce, etc.
* **By Popularity**: Most forked, highest rated, recently updated
* **By Industry**: Restaurants, healthcare, consulting, retail, etc.
* **By Features**: File uploads, payment processing, automation complexity
**Search and Filter:**
```
Search: "customer feedback restaurant"
Filters: β 4+ stars, π΄ 50+ forks, π
Updated this month
```
### How to Fork an App
1. **Find the app** you want in the community marketplace
2. **Click "Preview"** to test functionality and see what it does
3. **Review the description** and setup requirements
4. **Click "Fork to My Workspace"**
5. **Choose destination workspace** (if you have multiple)
6. **Wait 30-60 seconds** for the complete copy process
7. **Your forked app appears** in your workspace, fully functional
### What You Get When Forking
**Complete Workspace Copy:**
* **All Projects**: Data structures, custom fields, templates
* **AI Agents**: Trained agents with their knowledge and personalities
* **Automations**: Workflows, triggers, and third-party integrations
* **Media Files**: Images, documents, logos, and assets
* **Configurations**: Settings, permissions, and customizations
**Independence:**
* Your fork is completely separate from the original
* Make any changes without affecting the source app
* Update, rebrand, or modify freely
* No ongoing connection to the original creator
***
## Fork vs. Template vs. Clone
Understanding the differences helps you choose the right approach:
| Feature | Fork | Template | Clone |
| ----------------- | --------------------- | ------------------- | --------------------- |
| **Source** | Community apps | Taskade templates | Your own apps |
| **Content** | Complete workspace | Structure only | Exact copy |
| **Data** | Example data included | Empty/placeholder | Your actual data |
| **Agents** | Fully trained | Basic setup | Identical training |
| **Automations** | All connections | Framework only | All your integrations |
| **Customization** | Fully editable | Highly customizable | Identical copy |
***
## Best Practices for Community Success
### Creating Shareable Apps
**Design for Reusability:**
```
β "Sarah's Restaurant Feedback System"
β
"Restaurant Customer Feedback & Manager Alerts"
β Hard-coded email addresses and phone numbers
β
Placeholder values that users can easily customize
β Complex setup requiring 10+ integration steps
β
Simple setup with clear documentation
```
**Include Complete Examples:**
* Sample data that demonstrates all features
* Example automations that work out of the box
* Clear naming conventions that make sense to outsiders
* Help text and tooltips explaining business logic
### Writing Great Descriptions
**Be Specific About Value:**
```
β "Helps with customer stuff"
β
"Collects customer feedback with 1-5 star ratings, instant manager alerts for low scores, and weekly performance reports"
β "Good for restaurants"
β
"Perfect for restaurants, cafes, food trucks, and any food service business wanting to improve customer satisfaction"
```
**Include Setup Requirements:**
```
"This app works immediately after forking, but for full functionality you'll need:
β’ Slack workspace for manager alerts (5 minutes)
β’ Email service for customer confirmations (optional)
β’ No coding or technical knowledge required"
```
### Optimizing for Discovery
**Choose Effective Tags:**
* **Business Function**: "feedback", "booking", "inventory", "crm"
* **Industry**: "restaurant", "healthcare", "consulting", "retail"
* **Features**: "mobile-friendly", "payments", "automation", "reporting"
* **Skill Level**: "beginner", "intermediate", "advanced"
**Update Regularly:**
* Fix bugs reported by community users
* Add requested features when possible
* Keep screenshots current with any UI changes
* Respond to comments and questions
***
## Popular Community Categories
### Customer Experience
* **Feedback Collection**: Rating systems, review management
* **Support Portals**: Ticket systems, knowledge bases
* **Booking Systems**: Appointments, reservations, scheduling
* **Onboarding Flows**: Welcome sequences, setup wizards
### Business Operations
* **Inventory Management**: Stock tracking, reorder alerts
* **Lead Management**: Sales pipelines, follow-up systems
* **Employee Tools**: Onboarding, performance tracking
* **Financial Tracking**: Expense reports, budget monitoring
### Content & Marketing
* **Content Calendars**: Social media planning, publication schedules
* **Campaign Tracking**: Marketing performance, ROI analysis
* **Brand Management**: Asset libraries, style guide compliance
* **Event Management**: Registration, attendee tracking
### Industry-Specific Solutions
* **Restaurant**: Menu management, table reservations, staff scheduling
* **Healthcare**: Patient intake, appointment reminders, billing
* **Real Estate**: Property listings, client management, tour scheduling
* **Education**: Course management, student tracking, assignment submission
***
## Privacy & Security Considerations
### Before Publishing
**Data Sanitization:**
* Remove all real customer data and replace with examples
* Clear any API keys, passwords, or credentials
* Scrub email addresses, phone numbers, and personal information
* Review all text fields for sensitive business information
**Access Control Review:**
* Ensure no private integrations remain connected
* Remove any workspace-specific permissions
* Clear personalized settings and preferences
* Test with a fresh account to verify clean state
### Community Guidelines
**Prohibited Content:**
* Apps containing real personal or business data
* Malicious code or security exploits
* Copyright-infringing content or branding
* Spam or low-quality submissions
**Best Practices:**
* Use placeholder data that clearly demonstrates functionality
* Include proper attribution for any third-party resources
* Respect intellectual property and create original solutions
* Provide honest, accurate descriptions of capabilities
***
## Analytics & Performance
### Community App Metrics
**Core Statistics:**
* **Fork Count**: How many users have copied your app
* **View Count**: Total marketplace views and previews
* **Rating Average**: User satisfaction scores
* **Review Count**: Detailed feedback from community
**Performance Insights:**
* **Popular Features**: Which parts get used most
* **User Feedback**: Common questions and requests
* **Update Impact**: How changes affect usage metrics
* **Category Ranking**: Position within your app category
### Growing Your Community Presence
**Engagement Strategies:**
* **Respond to Reviews**: Address questions and thank users
* **Regular Updates**: Keep apps current with new features
* **Cross-Promotion**: Reference your apps in forum discussions
* **Documentation**: Create helpful guides and tutorials
**Building Reputation:**
* **Quality Over Quantity**: Focus on polished, useful apps
* **User Support**: Help community members succeed with your apps
* **Innovation**: Pioneer new solutions and approaches
* **Collaboration**: Work with other community builders
***
## Advanced Community Features
### Embedding Community Apps
A published community app is a standard Taskade Genesis app, so you can embed it in any web page with an `
```
Copy the exact URL from the app's **Share** panel.
### API Integration with Community Apps
Apps you clone from the community are standard Genesis apps. Build integrations with the [public API](/developers/developer-home), and have an app call external services securely through the [App Secrets](/taskade-genesis/space-apps-guide/app-secrets) outbound proxy β there is no separate `community` API surface.
### Collaborative Development
**Community Feedback Integration:**
* Feature request voting systems
* Bug report tracking
* Collaborative improvement suggestions
* Community-driven documentation
***
## Troubleshooting Common Issues
### Publishing Problems
**Issue**: App won't publish to community **Solutions**:
* Ensure all sensitive data is removed
* Check for required fields in the listing form
* Verify app is in a published state (not draft)
* Review content guidelines compliance
**Issue**: Low discovery/fork rate **Solutions**:
* Improve app description with specific benefits
* Add better screenshots and preview content
* Choose more effective tags and categories
* Respond to user reviews and questions
### Forking Problems
**Issue**: Forked app doesn't work properly **Solutions**:
* Check if original app requires specific integrations
* Review setup instructions provided by creator
* Ensure all media files transferred correctly
* Contact app creator for support
**Issue**: Can't customize forked app **Solutions**:
* Verify you have full ownership of the forked copy
* Check workspace permissions and roles
* Ensure you're editing the fork, not viewing the original
* Contact Taskade support if restrictions seem incorrect
***
## Resources & Support
### Community Documentation
* [**Community Guidelines**](https://www.taskade.com/learn/genesis/community-gallery) - Rules and best practices
* [**Publishing Checklist**](https://www.taskade.com/learn/genesis/publishing) - Pre-publication review steps
* [**Community Success Tips**](https://www.taskade.com/learn/genesis/community-kits) - Growing your presence
### Getting Help
* **Community Forum**: Connect with other builders and users
* **Creator Support**: Special support channel for active community contributors
* **Documentation Requests**: Help improve community resources
* **Bug Reports**: Report issues with community features
### Learning Resources
* **Community Showcase**: Featured apps and case studies
* **Builder Interviews**: Learn from successful community creators
* **Best Practice Guides**: Detailed tutorials and examples
* **Video Walkthroughs**: Step-by-step creation and publishing guides
***
## Ready to Share Your Genius?
The Taskade community is waiting to discover your innovative solutions. Whether you've built the perfect customer feedback system, an ingenious inventory tracker, or a game-changing team dashboard, sharing it helps teams worldwide while establishing your expertise.
### Quick Start Checklist
* [ ] **Review your app** for sensitive data and polish completeness
* [ ] **Test all features** work correctly with example data
* [ ] **Write clear descriptions** of value and use cases
* [ ] **Add helpful screenshots** and preview content
* [ ] **Choose effective tags** for discoverability
* [ ] **Publish to community** and monitor initial feedback
* [ ] **Engage with users** who fork and review your app
### Next Steps
1. **Browse existing community apps** for inspiration and to see what's popular
2. **Fork a few interesting apps** to understand the user experience
3. **Identify gaps in the marketplace** where your expertise can help
4. **Build and refine your solution** with community sharing in mind
5. **Publish your first community app** and start making an impact
***
**π Build something amazing. Share it with the world. Help teams everywhere work smarter.**
*The future of work is collaborative, and your Genesis app could be exactly what someone needs to transform their business.*
# Publish & Clone
Publish, clone, and sell Taskade Genesis apps with live URLs, password protection, custom domains, SEO, white-label branding, and paid copies.
***
## Table of Contents
* [Overview](#overview)
* [What "Publish" Means](#what-publish-means)
* [App Visibility Settings](#app-visibility-settings)
* [Publishing Strategies](#publishing-strategies)
* [Password Protection](#password-protection)
* [Publish to Community Gallery](#publish-to-community-gallery)
* [Clone and Remix Apps](#clone-and-remix-apps)
* [Paid Apps](#paid-apps)
* [Custom Domains](#custom-domains)
* [Advanced Sharing Options](#advanced-sharing-options)
* [Embedding Your App](#embedding-your-app)
* [SEO Customization](#seo-customization)
* [White-Label Branding](#white-label-branding)
* [Enterprise SSO (OIDC)](#enterprise-sso-oidc)
* [Security Considerations](#security-considerations)
* [Sharing Methods at a Glance](#sharing-methods-at-a-glance)
* [What's Next](#whats-next)
***
## Overview
Once you've built an app with Taskade Genesis, you can share it with the world in multiple ways β from private team tools to public community templates. This guide covers every publishing, sharing, and distribution option available.
> **Haven't built an app yet?** Start with [Create Your First App](/taskade-genesis/genesis/getting-started).
***
## What "Publish" Means
When you publish a Genesis app, it becomes a **live, accessible application**:
| What Happens | Detail |
| ----------------------------- | --------------------------------------------------------- |
| **Live URL** | Your app gets a shareable URL anyone can access |
| **Real-time functionality** | All features work β forms, databases, agents, automations |
| **Powered by your workspace** | Backend databases, AI agents, and automations run live |
| **Clone-ready** | Others can fork your app into their own workspace |
| **Analytics active** | Visitor tracking begins immediately |
| **Version controlled** | Every published version is saved and restorable |
***
## App Visibility Settings
| Visibility | Who Can Access | Discoverable | Best For |
| ----------- | ---------------------- | --------------------------------- | ------------------------------------------------ |
| **Public** | Anyone on the internet | Yes β listed in Community Gallery | Templates, showcases, community tools, marketing |
| **Secret** | Anyone with the link | No β link-only access | Client portals, team tools, partner apps |
| **Private** | Workspace members only | No | Internal dashboards, company tools |
***
## Publishing Strategies
Genesis supports two publishing strategies:
| Strategy | How It Works | Best For |
| ---------- | ------------------------------------- | ----------------------------------------------------------------- |
| **Auto** | Every change is published immediately | Development/testing phase, rapid iteration, internal tools |
| **Manual** | You choose when to publish | Production apps, client-facing tools, quality-controlled releases |
> **Tip:** Start with Auto while building, switch to Manual when your app is live with real users. You can change this anytime in app settings.
***
## Password Protection
Add an extra layer of security to any published app:
| Step | Action |
| ---- | --------------------------------------------------- |
| 1 | Open your app's **Publish** settings |
| 2 | Toggle **"Require Password"** on |
| 3 | Set your password |
| 4 | Share the password separately with authorized users |
| Feature | Detail |
| ---------------- | --------------------------------- |
| Available on | All plans |
| Protection level | Site-wide β covers entire app |
| Password sharing | Manual (share via secure channel) |
| Can be changed | Yes, anytime in settings |
***
## Publish to Community Gallery
Share your app with the entire Taskade community:
| Step | Action |
| ---- | --------------------------------------------------------- |
| 1 | Set your app visibility to **Public** |
| 2 | Click **"Publish to Community"** |
| 3 | Your app enters the community approval queue |
| 4 | Once approved, it appears in the public Community Gallery |
### Community App Metrics
Published community apps track engagement automatically:
| Metric | What It Measures |
| ---------------------- | -------------------------------------- |
| **Views** | How many people viewed your app |
| **Likes** | Community engagement and endorsement |
| **Installs** | How many people cloned/forked your app |
| **Intelligence Score** | Your app's DNA maturity (0β100) |
> **Community status flow:** Pending β Approved / Rejected. You can unsubmit anytime.
***
## Clone and Remix Apps
Cloning is the fastest way to start β pick a working app, copy it to your workspace, and customize it instead of building from a blank prompt. Browse apps to clone in the [community gallery](https://www.taskade.com/community) and [Taskade's official kits](https://www.taskade.com/user/taskade).
Any public or shared app can be cloned:
| Step | Action |
| ---- | ------------------------------------------------------- |
| 1 | Open a published app (yours or someone else's) |
| 2 | Click **"Edit in Taskade"** |
| 3 | Click **"Clone"** |
| 4 | The app is copied to your workspace with all components |
### What Gets Cloned
| Component | Cloned? | Notes |
| --------------------- | ------- | -------------------------------------------------------------- |
| **UI / Frontend** | Yes | Full React app code |
| **Project databases** | Yes | Structure + sample data |
| **AI agents** | Yes | Agent config + knowledge references |
| **Automations** | Yes | Flow definitions (may need re-authentication for integrations) |
| **Media files** | Yes | Images, uploads |
| **Custom domain** | No | You'll need to configure your own |
| **Analytics data** | No | Fresh start with new metrics |
| **Passwords** | No | Set your own |
***
## Prefilled Taskade Genesis Links
You can share a link that opens Taskade Genesis with an app description already filled in, so the recipient generates it in one click instead of retyping the idea.
**Link format:**
```
https://www.taskade.com/create?input=YOUR_APP_DESCRIPTION
```
When opened, Taskade Genesis loads with the description pre-populated and ready to generate β the recipient can still edit it first. The `input` value is URL-encoded (a space becomes `%20`); most browsers encode it automatically when you copy the link back out of the address bar.
{% hint style="info" %}
Specific descriptions produce better results: "Create a restaurant reservation system with table availability, guest preferences, and confirmation emails" works far better than "Build a booking app." Very long descriptions may hit browser URL-length limits.
{% endhint %}
***
## Paid Apps
Genesis lets creators monetize their apps directly. When you enable monetization for an app, buyers pay via Stripe before receiving their own private copy.
### How It Works
| Step | What Happens |
| --------------------------------- | ----------------------------------------------------------------------------------------------- |
| **Creator sets a price** | In the app's **Publish** settings, open the **Monetization** panel and set a price for the app. |
| **Buyer discovers the app** | The app appears in the Community Gallery (or via a direct link) with a price tag. |
| **Buyer pays via Stripe** | Checkout is handled by Stripe. No payment details are stored by Taskade. |
| **Buyer receives a private copy** | After successful payment, Taskade clones the app directly into the buyer's workspace. |
### Key Rules for Paid App Copies
| Rule | Detail |
| --------------------------- | ------------------------------------------------------------------------------------------------------------- |
| **Scope** | Cloned paid apps are scoped to the buyer's workspace only. |
| **Re-sharing** | Buyers cannot re-publish or redistribute paid app copies to other users. |
| **Clone ancestry** | Taskade tracks clone lineage β each paid copy is linked to the original app and its creator. |
| **No revenue figures here** | Payout terms and percentages are shown in your Monetization dashboard, not documented here β they may change. |
{% hint style="info" %}
Paid apps do not affect the buyer's ability to customize or extend the app within their own workspace. Re-sharing and re-selling the cloned copy is blocked to protect creator rights.
{% endhint %}
***
## Custom Domains
Connect your own domain to any published Genesis app:
| Feature | Detail |
| ----------------- | -------------------------------- |
| **Available on** | Business+ plans |
| **Setup method** | CNAME record pointing to Taskade |
| **SSL** | Automatic via Cloudflare |
| **Configuration** | App Settings β Domains |
| Step | Action |
| ---- | ------------------------------------------------------ |
| 1 | Open app **Settings** β **Domains** |
| 2 | Enter your custom domain (e.g., `app.yourcompany.com`) |
| 3 | Add the provided CNAME record to your DNS provider |
| 4 | Wait for DNS propagation (up to 24 hours) |
| 5 | SSL certificate is provisioned automatically |
***
## Advanced Sharing Options
| Feature | Description | Plan |
| ------------------------ | ------------------------------------------------ | ---------- |
| **Direct link** | Copy and share the app URL | All |
| **Embed** | Embed app in your website or blog via iframe | All |
| **Social sharing** | Share on LinkedIn, Twitter, Reddit, Facebook | All |
| **SEO customization** | Custom meta title, description, Open Graph image | Business+ |
| **Custom colors** | Branded share previews and social cards | Business+ |
| **White-label branding** | Custom favicon, remove Taskade branding | Business+ |
| **OIDC authentication** | Enterprise SSO for app access | Enterprise |
***
## Embedding Your App
You can embed any published Genesis app into an external website, blog, or documentation page using an iframe.
### Getting the Embed Code
1. Open your published app.
2. Click the **Share** menu (top-right of the app toolbar).
3. Select **Embed** to reveal the embed code snippet.
4. Copy the `
```
| Attribute | Recommended Value | Why |
| ----------------- | --------------------------- | -------------------------------------------- |
| `width` | `100%` | Fills the container responsively |
| `min-height` | `600px` (adjust to content) | Prevents the frame from collapsing |
| `border` | `none` | Removes the default iframe border |
| `allowfullscreen` | present | Allows modal/fullscreen views inside the app |
{% hint style="info" %}
If your embedding site enforces a `Content-Security-Policy` with `frame-ancestors`, you must add `taskade.com` (or your custom domain) to the allowed-origin list. Frames blocked by CSP will show a blank panel with no error visible to the end user.
{% endhint %}
***
## SEO Customization
Genesis apps support custom search-engine and social metadata so your published app is discoverable and looks polished when shared.
### How to Set SEO Fields
1. Open your app's **Publish** settings.
2. Locate the **SEO** panel.
3. Fill in the fields described below.
4. Save and republish (or let Auto-publish apply the change).
| Field | What It Controls | Tips |
| -------------------- | --------------------------------------------------------------------- | --------------------------------------------------------------------- |
| **Meta title** | The `` tag and browser tab label | Keep under \~60 characters to avoid truncation in search results |
| **Meta description** | The snippet shown in search results | Aim for \~150 characters; describe what the app does and who it's for |
| **Open Graph image** | The preview image on social shares (LinkedIn, X/Twitter, Slack, etc.) | Recommended size 1200 Γ 630 px; upload via the OG Image field |
{% hint style="info" %}
The Open Graph image you upload is stored in your workspace assets. If you later delete the asset, the social preview will fall back to the Taskade default image.
{% endhint %}
***
## White-Label Branding
Business+ workspaces can strip or replace Taskade's default branding on published apps.
### How to Configure White-Label Options
1. Open your app's **Publish** settings.
2. Navigate to the **Branding** panel.
3. Apply the options below and save.
| Option | What It Does |
| -------------------- | ----------------------------------------------------------------------------- |
| **Watermark toggle** | Hides the "Powered by Taskade" badge from the published app footer |
| **Favicon upload** | Replaces the default Taskade favicon with your own `.ico` or `.png` file |
| **Color theme** | Sets primary and accent colors for the app chrome to match your brand palette |
{% hint style="info" %}
White-label settings apply to the published view only. The Taskade editor interface retains standard Taskade branding for workspace members.
{% endhint %}
***
## Enterprise SSO (OIDC)
Enterprise workspaces can gate app access behind your organization's Identity Provider (IdP) using OpenID Connect (OIDC). This means visitors must sign in through your corporate SSO before they can view or interact with the app.
Contact sales to enable OIDC for your workspace β setup guidance is provided during Enterprise onboarding.
***
## Security Considerations
| Practice | Recommendation |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| **Sensitive data** | Never publish apps containing passwords, API keys, or PII publicly |
| **Private links** | Use Secret visibility for confidential applications |
| **Password protection** | Add site-wide password for client portals |
| **Access review** | Regularly review who has access to your published apps |
| **Automation credentials** | Integration credentials are workspace-level, not exposed in published apps |
| **Version awareness** | Old published versions may contain data you later removed β use [Version History](/taskade-genesis/genesis/version-history) to audit |
***
## Sharing Methods at a Glance
| Method | Visibility | Clonable | Custom Domain | Password | Analytics | Best For |
| ------------------------- | ----------------------- | --------------- | ------------- | -------- | --------- | ---------------------------------------------------------------------------------------- |
| **Public + Community** | Anyone | Yes | Business+ | Optional | Yes | Templates, showcases |
| **Public (no community)** | Anyone with URL | Yes | Business+ | Optional | Yes | Marketing pages |
| **Secret link** | Link holders | Yes | Business+ | Optional | Yes | Client portals, partners |
| **Private** | Workspace only | N/A | Business+ | Optional | Yes | Internal tools |
| **Embed** | Website visitors | No | N/A | Optional | Yes | Blog, documentation |
| **Paid** | Anyone (after purchase) | Yes (paid copy) | Business+ | Optional | Yes | Monetized templates, premium apps β buyer receives a private copy in their own workspace |
***
## What's Next
| Guide | What You'll Learn |
| ------------------------------------------------------------------------------------- | ---------------------------------------------------- |
| [Genesis Version History](/taskade-genesis/genesis/version-history) | Track changes and restore previous versions |
| [App Analytics](/taskade-genesis/genesis/app-analytics) | Monitor visitor data and optimize your app |
| [Create Your First App](/taskade-genesis/genesis/getting-started) | Build something to publish |
| [Taskade AI Credits](https://www.taskade.com/learn/agents/ai-usage) | Understand credit costs for app operations |
| [Sharing Best Practices](/community-and-sharing/community-and-sharing/best-practices) | Tips for collaborating and distributing apps |
| [Sharing FAQ](/community-and-sharing/community-and-sharing/faq) | Common questions about publishing and access |
| [Developer Platform](/developers/developer-home) | Publish and manage apps programmatically via the API |
# GenesisAuth
Add secure user accounts and sign-in to Taskade Genesis apps with GenesisAuth: no-code App Users, workspace SSO, and custom-domain login.
A dedicated security layer for Taskade Genesis apps. Every Taskade Genesis app can ship with real user accounts and secure sign-in β no code, no third-party provider setup, no DevOps.
***
## Table of Contents
* [What Is GenesisAuth](#what-is-genesisauth)
* [Turning Any App Into a Multi-User Product](#turning-any-app-into-a-multi-user-product)
* [The App Users Tab](#the-app-users-tab)
* [Workspace Single Sign-On](#workspace-single-sign-on)
* [Custom Domain Sign-In](#custom-domain-sign-in)
* [Access Control](#access-control)
* [How It Works Under the Hood](#how-it-works-under-the-hood)
* [Security Best Practices](#security-best-practices)
* [Related](#related)
***
## What Is GenesisAuth
GenesisAuth is the authentication layer for apps built with Taskade Genesis. When you describe an app that needs user accounts, Taskade wires up secure sign-in automatically β session management, credential handling, and access control all work out of the box.
* **Built-in user accounts.** No Auth0 or Clerk to wire up, no schema to design.
* **Pre-built sign-in component** added to the generated app automatically.
* **Scales with your app.** Handles sessions, password hashing, and session tokens securely.
* **Turns every Taskade Genesis app into a real multi-user product.**
<figure><img src="/files/q0GwWv3NRVvnnAKQfRQw" alt="" width="563"><figcaption></figcaption></figure>
***
## Turning Any App Into a Multi-User Product
You don't configure GenesisAuth manually β you describe the need.
1. In Taskade Genesis, describe your app in plain language. Include phrases like:
* *"a client portal where each client has their own dashboard"*
* *"users can sign in to see their own habit streaks"*
* *"a members-only knowledge base"*
2. Taskade EVE generates the app **with the sign-in component in place**.
3. Open the app's settings to review the **App Users** tab.
That's it. Your app now accepts user sign-ups, handles sign-in, and enforces per-user data access.
{% hint style="info" %}
If your first prompt doesn't trigger auth setup, you can add it later by asking Taskade EVE to *"add sign-in for users"* while editing the app.
{% endhint %}
{% hint style="success" %}
**Sign-in is always real.** If a build or edit ever produces a login screen that doesn't actually authenticate, Taskade EVE detects it and automatically replaces it with working, persistent authentication β GenesisAuth sign-in by default, or secure hashed-credential storage for apps that manage their own user directory. EVE tells you when it makes this repair.
{% endhint %}
***
## The App Users Tab
The **App Users** tab lives in your Taskade Genesis app's settings. It's a first-class user management dashboard.
### What You Can Do
* See the list of end users who have signed in to your app.
* Invite new users by email.
* Suspend access without deleting accounts.
* Remove accounts entirely.
All without touching code.
<figure><img src="/files/Fmsa9RZJiWUTSruqx8xA" alt="" width="563"><figcaption></figcaption></figure>
{% hint style="info" %}
The App Users tab is currently in Beta. The feature is rolling out across paid plans β bug reports welcome at [github.com/taskade/taskade/issues](https://github.com/taskade/taskade/issues).
{% endhint %}
***
## Workspace Single Sign-On
Workspace members can sign in to any Genesis app using their existing Taskade workspace identity.
* One identity across your workspace and all your apps.
* No separate account for each Genesis app.
* Sign-in flows work on both Taskade-hosted and custom-domain deployments.
This is especially useful for internal tools β team members use their Taskade credentials and you don't have to manage a second user directory.
***
## Custom Domain Sign-In
GenesisAuth works seamlessly on apps hosted at your own domain.
* No additional configuration required when you connect a custom domain.
* Session cookies and redirects handle custom domains correctly.
* Specific reliability improvements were added for sign-in flows on custom domains.
{% hint style="success" %}
Combine GenesisAuth with a [custom domain](/taskade-genesis/space-apps-guide/custom-domains) to deliver a fully branded, production-ready product to end users.
{% endhint %}
***
## Access Control
GenesisAuth is part of a broader access-control story.
| Control | What It Does | When to Use |
| ------------------------------- | --------------------------------------- | ------------------- |
| GenesisAuth (App Users) | Account-based sign-in for app end users | Any multi-user app |
| Workspace SSO | Taskade identity for workspace members | Internal tools |
| Password-protected public links | Single shared password for a link | Quick gated preview |
| Private / Unlisted visibility | Controls discoverability | Non-indexed sharing |
| Public agent tool opt-out | Sensitive tools stay workspace-only | Published agents |
<figure><img src="/files/TJ4YBGvGE4NNE0le9tG4" alt="" width="563"><figcaption></figcaption></figure>
***
## How It Works Under the Hood
You don't need to know these details to use GenesisAuth, but they matter if you're auditing the security model.
* **Token-based session management.** Sign-in produces a secure session token stored in an HTTP-only cookie.
* **Sessions persist across updates.** Signed-in users stay signed in through app updates β no forced re-login.
* **No credentials in the app bundle.** Exported app bundles never contain end-user credentials or session tokens β only the app structure.
* **Per-app user isolation.** Each Genesis app's App Users list is scoped to that app.
***
## Security Best Practices
* **Review exposed tools.** For public agents, opt sensitive tools out so external users can't invoke them.
* **Suspend instead of delete** when you want to retain a user's history but block access.
* **Use a custom domain with TLS** for any app that handles user data in production.
* **OIDC sign-in is hardened by default.** OIDC lets workspaces gate app access behind their own identity provider; PKCE is an OAuth security check that stops intercepted sign-in codes from being replayed. Taskade accepts only the S256 PKCE method and validates that `redirect_uri` matches your app's own origin. See [Enterprise SSO (OIDC)](/community-and-sharing/community-and-sharing/publish-and-clone#enterprise-sso-oidc) and the [authentication guide](/developers/authentication).
* **Monitor sign-in activity** via the App Users tab and your workspace activity log.
* **Rotate workspace tokens** periodically if you also expose the app via the [Public API](/developers/authentication).
***
## Related
{% content-ref url="/pages/eUzUJ1ZV9iFxG7Zt4rGa" %}
[Publish & Clone](/community-and-sharing/community-and-sharing/publish-and-clone)
{% endcontent-ref %}
{% content-ref url="/pages/EP31ZGsWFRR3qDXVE8G5" %}
[Put Your App on Your Own Domain](/taskade-genesis/space-apps-guide/custom-domains)
{% endcontent-ref %}
{% content-ref url="/pages/rb1gtgCtNiAXixHaOt4F" %}
[Authentication](/developers/authentication)
{% endcontent-ref %}
# Best Practices
Best practices for building Taskade Genesis apps: write effective prompts, test on mobile, iterate one change at a time, and avoid common pitfalls.
Learn from successful Taskade Genesis users to build better apps faster and avoid common pitfalls.
## Writing Effective Prompts
The quality of your prompt directly impacts the quality of your app. Here's how to write prompts that get great results.
### The Perfect Prompt Formula
**Industry + Users + Problem + Solution + Outcome = Great Results**
```
I run a [INDUSTRY] and [USERS] need to [PROBLEM] because [CONTEXT]. They should be able to [SOLUTION] and when they do, [OUTCOME] should happen automatically.
```
### Be Specific About Your Industry
β **Too generic:** "I need a booking system"
β
**Industry-specific:** "I run a veterinary clinic and pet owners need to book appointments for their animals"
**Why this matters:** Different industries have different requirements, terminology, and user expectations. A booking system for a vet clinic needs different features than one for a hair salon.
### Describe the Complete User Journey
β **Incomplete:** "Customers can book appointments"
β
**Complete journey:** "Customers browse available times, select their preferred veterinarian, choose appointment type (checkup, vaccination, emergency), provide pet information, pay a deposit, receive confirmation with pre-visit instructions, and get reminder calls 24 hours before their appointment"
### Include Business Rules and Constraints
β **Vague:** "Handle cancellations"
β
**Specific rules:** "Allow cancellations up to 24 hours before appointment time with full refund, cancellations within 24 hours forfeit the deposit, and emergency cancellations due to pet illness can be rescheduled without penalty"
### Specify Your Audience
**Consider these factors:**
* **Technical comfort level:** "Elderly clients who prefer simple interfaces"
* **Device usage:** "Busy parents who primarily use mobile phones"
* **Context of use:** "Staff who need to quickly enter data between customer interactions"
## Testing Your App
### Test Like a Real User
**Use realistic scenarios:**
```
β
Book an appointment for your actual pet with real dates
β
Submit feedback about a meal you actually ate
β
Upload a real document that your customers would submit
```
**Avoid testing shortcuts:**
```
β Using "test@test.com" as an email
β Entering "asdf" in text fields
β Skipping optional fields that real users might fill out
```
### Mobile-First Testing
**Test on actual devices:**
* Pull out your phone and use the app
* Try typing on the mobile keyboard
* Test with poor internet connection
* Check how it looks in both portrait and landscape
**Common mobile issues to watch for:**
* Buttons too small to tap easily
* Text too small to read
* Forms that don't work with mobile keyboards
* Images that don't load on slower connections
### Test Edge Cases
**What happens when:**
* Someone uploads a very large file?
* A user enters special characters or emojis?
* Multiple people try to book the same time slot?
* Someone leaves required fields blank?
* The internet connection is slow or interrupted?
### Get Real User Feedback
**Start with a small group:**
* Choose 3-5 people who represent your actual users
* Watch them use the app (don't just ask for their opinion)
* Take notes on where they hesitate or seem confused
* Ask specific questions: "Was it clear how to submit your request?"
## Iterating and Improving
### Make One Change at a Time
β **Too many changes at once:**
```
"Make the button bigger, change the colors, add a progress bar, connect to our CRM, and add a payment system"
```
β
**One focused change:**
```
"Make the submit button bigger and more prominent so it's easier to find on mobile devices"
```
**Why this matters:** When you change multiple things at once, you can't tell which change caused which result. If something breaks, you won't know what to fix.
### Test Each Change
**After each modification:**
1. **Test the specific change** you made
2. **Make sure you didn't break** anything else
3. **Get feedback** from users if it's a significant change
4. **Document what worked** and what didn't
### Use Data to Guide Decisions
**Track meaningful metrics:**
* How many people complete the main action (conversion rate)
* Where people drop off in the process
* How long it takes people to complete tasks
* What questions or problems come up most often
**Ask the right questions:**
* "Where do people get stuck?"
* "What features do people use most?"
* "What do people ask for help with?"
## Managing Your App
### Document Your Setup
**Keep track of:**
* **Integrations:** Which services are connected and how
* **Automations:** What triggers what actions
* **User roles:** Who has access to what features
* **Business rules:** Special policies or requirements
**Why this matters:** When you need to make changes or train new team members, you'll want to remember how everything works.
### Plan for Growth
**Start simple, scale thoughtfully:**
1. **Build for your current needs** first
2. **Monitor usage patterns** to see what's working
3. **Add features based on actual user requests** rather than assumptions
4. **Test new features with a small group** before rolling out to everyone
### Maintain Your App
**Regular maintenance tasks:**
* **Test integrations** to make sure they're still working
* **Review user feedback** for improvement opportunities
* **Update content** like pricing or service descriptions
* **Clean up old data** that's no longer needed
## Team Collaboration
### Getting Team Buy-In
**Include your team in the process:**
* **Show them early versions** and get their input
* **Train them on how to use** the app effectively
* **Ask for their ideas** on improvements
* **Celebrate successes** when the app helps the business
### Assign Ownership
**Clear responsibilities:**
* **Who updates content** like prices or service descriptions?
* **Who monitors** for problems or user feedback?
* **Who responds** to customer questions about the app?
* **Who makes decisions** about new features or changes?
## Security and Privacy
### Protect User Data
**Essential security practices:**
* **Use strong passwords** for admin accounts
* **Limit access** to only the people who need it
* **Regular backups** of important data
* **Monitor for suspicious activity** or unauthorized access
### Be Transparent
**Clear communication with users:**
* **Explain what data you collect** and why
* **Provide options** for users to control their information
* **Make it easy** for users to update or delete their data
* **Respond quickly** to privacy concerns or questions
## Common Mistakes to Avoid
### Over-Engineering
β **Building for imaginary future needs:**
```
"Add advanced analytics, multi-language support, and integration with 10 different services in case we need them someday"
```
β
**Building for current reality:**
```
"Build a simple feedback form that works well for our current customers and can be enhanced later if needed"
```
### Ignoring User Feedback
β **Assuming you know what users want:**
```
"The app is perfect as designed, users just need to learn how to use it properly"
```
β
**Listening and adapting:**
```
"Three people mentioned the same confusion, let's fix that before rolling out to more users"
```
### Perfectionism Paralysis
β **Waiting for perfection:**
```
"We can't launch until every possible feature is built and every edge case is handled"
```
β
**Iterative improvement:**
```
"Let's launch with the core features working well and add enhancements based on real usage"
```
### Feature Creep
β **Adding features without purpose:**
```
"Let's add a chat feature and social media integration because other apps have them"
```
β
**Purpose-driven development:**
```
"Our users are asking for a way to communicate with our team, so let's add a simple contact form"
```
## Success Metrics
### Define Success Early
**Before building, decide what success looks like:**
* **Usage metrics:** How many people use the app?
* **Completion rates:** Do people finish the main action?
* **Time savings:** Does this make processes faster?
* **Customer satisfaction:** Are people happier with this experience?
* **Business impact:** Does this help achieve business goals?
### Regular Check-Ins
**Monthly review questions:**
* Is the app being used as expected?
* What feedback are we getting from users?
* Are our integrations still working properly?
* What improvements would have the biggest impact?
* Should we add new features or simplify existing ones?
## Getting the Most from Genesis
### Leverage the AI Agent
**Use the built-in AI for ongoing improvements:**
```
"What features should I add to make this app better for my restaurant customers?"
"How can I improve the mobile experience for people booking appointments?"
"What integrations would be most useful for a customer feedback app?"
```
### Stay Updated
**Keep learning:**
* **Follow Genesis updates** for new features and capabilities
* **Join the community** to see what other users are building
* **Experiment with new features** as they become available
* **Share your successes** to help other users learn
### Think Beyond Your First App
**Once you've mastered one app:**
* **Identify other processes** that could benefit from automation
* **Consider apps for different audiences** (customers vs. internal team)
* **Build connected systems** where apps work together
* **Help other team members** build their own solutions
***
## Quick Reference Checklist
### Before Building
* [ ] Clearly define the problem you're solving
* [ ] Identify who will use the app and how
* [ ] Write a detailed prompt with business context
* [ ] Plan how you'll test the app
### During Development
* [ ] Test each feature as it's built
* [ ] Make one change at a time
* [ ] Get feedback from real users early
* [ ] Document important decisions and setup
### After Launch
* [ ] Monitor usage and gather feedback
* [ ] Plan regular maintenance and updates
* [ ] Train team members on using the app
* [ ] Measure success against your original goals
### Ongoing Success
* [ ] Listen to user feedback and iterate
* [ ] Keep security and privacy in mind
* [ ] Share successes and learn from others
* [ ] Look for opportunities to build additional apps
***
**Remember:** The best Genesis apps are built iteratively. Start with something simple that works, get it in front of real users, and improve based on their actual needs and feedback.
# FAQ
Taskade Genesis FAQ: how the no-code app builder works, build times, publishing and custom domains, data ownership, security, integrations, and pricing.
## Overview
### What is Taskade Genesis?
Taskade Genesis is like having a personal app developer who works instantly. You describe a business problem in plain English (like "I need customers to book appointments online"), and Genesis builds a complete working app for you - no coding, no setup, no technical knowledge required.
### How is this different from other app builders?
Genesis gives you the complete backend: Databases, Automation Workflows, AI Agents, and Integrations. Other tools just make interfaces.
**Genesis provides:**
* **Smart database** that stores your data automatically
* **AI assistant** that learns your business and helps customers
* **Automatic actions** that connect to your email, Slack, payment systems, etc.
* **Real functionality** - not just mockups or prototypes
* **Complete backend infrastructure** - hosting, security, and scaling handled automatically
**Other app builders require:**
* Manual database setup and configuration
* Separate hosting and deployment
* Third-party integrations you have to configure yourself
* Technical knowledge for backend functionality
Genesis handles all the technical complexity so you can focus on your business.
### What kinds of apps can I build?
**Popular app types:**
* **Customer portals** for service requests and communication
* **Team dashboards** for monitoring KPIs and workflows
* **Booking systems** for appointments and events
* **Inventory trackers** with smart alerts and reporting
* **Feedback forms** with automated response workflows
* **Project trackers** for task and deadline management
* **Workflow automation** for repetitive business processes
* **Custom tools** for industry-specific needs
### Do I need to know how to code?
No. Genesis understands business language and handles all technical implementation automatically. You focus on describing your business needs, and Genesis handles the programming.
## Building Your App
### How long does it take to build an app?
**Typical timeframes:**
* **Simple apps:** 2-5 minutes (basic forms, simple workflows)
* **Complex business applications:** 10-15 minutes including customization and testing
* **Enterprise-level apps:** 20-30 minutes with advanced features and integrations
### Can I change my app after Genesis builds it?
Yes! Describe any changes you want and Genesis implements them immediately. Your app evolves with your business needs - just tell Genesis what you want to adjust.
### What if the first version isn't quite right?
You have several options:
* **Make specific requests** for changes ("make the button bigger")
* **Provide more context** about what's not working
* **Start fresh** with a more detailed description if major changes are needed
Genesis gets better results with clearer requirements, so don't hesitate to be more specific about what you need.
### Can I see examples of what other people have built?
Yes! Check out:
* [**Examples and templates**](/taskade-genesis/genesis/examples-and-templates) in this documentation
* **Community showcase** in the Taskade forums
* **Video tutorials** on [YouTube](https://youtube.com/taskade)
* **Help center** case studies at [taskade.com/learn](https://www.taskade.com/learn)
## Sharing and Access
### How do I test my app before sharing it?
Use the **Preview feature** to interact with your app exactly as users will:
1. Click the "Preview" tab in your app
2. Test all functionality like a real user
3. Submit test data to ensure workflows work
4. Check that notifications and integrations trigger properly
5. Test on mobile devices if users will access via phone
### How do I publish my app?
Every app gets an **individual URL immediately**:
1. Click "Open" to view your live app
2. Copy the URL from your browser address bar
3. Share this link anywhere: email, social media, your website
4. No downloads or installations required for users
### Can I use my own domain name?
**Yes β custom domains are live.** You can connect your own branded URL (like `app.yourcompany.com`) to a published Genesis app instead of the default Genesis link, giving your apps a professional appearance that matches your brand.
### How do users access my app?
**Simple access:**
* Send them the link - no downloads or installations required
* Apps work in any web browser on desktop, tablet, or mobile phone
* Users can bookmark the link for easy return access
### Can I control who uses my app?
Yes! Tell Genesis what access you want and it sets it up:
* **"Make this app private with password protection"**
* **"Only allow users with company email addresses"**
* **"Require login for staff but allow public access for customers"**
If you set a password, make sure to share it along with the app link.
## Data and Security
### Where does my app data live?
Your app and all its data live in **Taskade's secure cloud infrastructure**. This includes:
* Your app's projects and databases
* Automation workflows and settings
* AI agent configurations
* User-submitted data and files
### Who owns the apps I create?
**You do.** Your apps, data, and intellectual property belong to you completely. We provide the platform and infrastructure, but everything you build and all the content within your apps remains your property. You can modify or delete data at any time.
### Is my data secure?
Yes. Taskade uses enterprise-grade security:
* **Encryption in transit and at rest**
* **Regular security audits and monitoring**
* **SOC 2 compliance** for data handling
* **Role-based access controls**
* **Automatic backups** to prevent data loss
### Can I export my data?
Yes. You can export your app data in standard formats (CSV, JSON) at any time. This ensures you're never locked into the platform and can migrate data if needed.
### What about GDPR and privacy compliance?
Taskade is GDPR compliant and provides tools to help you meet privacy requirements:
* **Data processing agreements** available for enterprise customers
* **User consent management** built into apps
* **Data deletion tools** for user requests
* **Privacy policy templates** for your apps
## Technical Questions
### What integrations are available?
**100+ integrations** including:
* **Communication:** Slack, Microsoft Teams, Discord
* **Email:** Gmail, Outlook, Mailchimp
* **File storage:** Google Drive, Dropbox, OneDrive
* **Payments:** Stripe, PayPal
* **CRM:** HubSpot, Salesforce, Pipedrive
* **Project management:** Trello, Asana, Monday.com
* **And many more...**
Can't find what you need? Contact support - we add new integrations regularly.
### Can I connect to my existing systems?
Yes! Genesis can integrate with:
* **Your current CRM or database**
* **Existing email marketing tools**
* **Accounting software** like QuickBooks
* **Calendar systems** for scheduling
* **Custom APIs** with webhook support
### What happens if Taskade goes down?
**Reliability measures:**
* **High-availability infrastructure** with redundancy
* **Automatic failover** systems
* **Real-time status monitoring** at taskade.statuspage.io
* **Data backups** stored in multiple locations
### Can I get help with complex integrations?
Yes! Several support options:
* **Email support** for technical questions
* **Live chat** for immediate help
* **Community forums** for peer assistance
* **Professional services** for enterprise implementations
## Billing and Plans
### How much does Genesis cost?
Genesis is included with Taskade subscriptions:
* **Free plan:** Limited apps and features
* **Pro plan:** Unlimited apps with advanced features
* **Business plan:** Team collaboration and enterprise features
Visit [taskade.com/pricing](https://taskade.com/pricing) for current pricing.
### What's included in the free plan?
**Free plan includes:**
* **Basic app creation** with Genesis
* **Simple automations** and integrations
* **Standard support** via help center
* **Community access** for questions and inspiration
### When should I upgrade to a paid plan?
**Consider upgrading when you need:**
* **Multiple apps** for different business functions
* **Advanced integrations** with business tools
* **Team collaboration** features
* **Priority support** for business-critical apps
* **Custom branding** and domain options
### Can I try advanced features before upgrading?
Yes! Most plans include a **free trial period** where you can test advanced features before committing to a paid subscription.
## Getting Support
### Where can I get help?
**Self-service resources:**
* **Help documentation:** [taskade.com/learn/genesis](https://www.taskade.com/learn/genesis)
* **Video tutorials:** [youtube.com/taskade](https://youtube.com/taskade)
* **Community forums:** Connect with other users
* **This documentation:** Comprehensive guides and examples
**Direct support:**
* **Email support:** <support@taskade.com>
* **Live chat:** Available in your Taskade dashboard
* **Community help:** Forums and user groups
### How do I report a bug or request a feature?
**For bugs:**
* **Email support** with detailed description
* **Include screenshots** if helpful
* **Provide your app URL** for faster troubleshooting
**For feature requests:**
* **Community forums** to see if others want the same feature
* **Email support** with business justification
* **User feedback** surveys when available
### What should I include in a support request?
**Essential information:**
* **What you're trying to build** (copy your prompt)
* **What you expected** to happen
* **What actually happened** (include screenshots if helpful)
* **Your app URL** if you need help with a specific issue
* **Error messages** if any appeared
### Can Genesis itself help me?
Yes! **Ask the AI agent directly:**
```
"What features should I add to make this app better for my customers?"
"How can I improve the user experience for mobile users?"
"What integrations would be most useful for a restaurant feedback app?"
```
The Genesis AI agent can provide suggestions, troubleshoot issues, and help you improve your apps.
## Best Practices
### How do I write better prompts?
**Follow the formula:** Industry + Users + Problem + Solution + Outcome
**Be specific about:**
* **Your industry** and business type
* **Who will use** the app and how
* **What problem** you're solving
* **What should happen** when users complete actions
**Genesis AI Tip:** Ask the AI agent itself for suggestions! Try prompts like "What features should I add to make this app better?" or "How can I improve the user experience?"
See our [Best Practices guide](/community-and-sharing/community-and-sharing/best-practices) for detailed examples.
### Should I build one big app or several smaller ones?
**Generally, smaller focused apps work better:**
* **Easier to build** and test thoroughly
* **Simpler for users** to understand and use
* **Faster performance** and loading times
* **Easier to maintain** and update
**Consider one large app when:**
* Users need to access multiple functions in one session
* Data needs to be shared between different functions
* You want a unified dashboard for everything
### How often should I update my app?
**Regular maintenance schedule:**
* **Weekly:** Check that integrations are working
* **Monthly:** Review user feedback and usage data
* **Quarterly:** Consider new features or improvements
* **As needed:** Fix bugs or address user complaints immediately
### How do I get inspiration for app ideas?
**Multiple sources of inspiration:**
* **Community showcase:** Browse real apps built by other users
* **Examples and templates:** Review our curated collection of app ideas
* **Industry-specific guides:** See how Genesis is used in your field
* **AI assistance:** Ask Genesis "What apps are popular in \[your industry]?"
* **Video tutorials:** Watch real examples being built on YouTube
***
## Quick Answers
**Q: Can I duplicate an app I've built?** A: Not directly, but you can use the same prompt to build a similar app and then customize it for different needs.
**Q: What's the maximum number of users per app?** A: No hard limits, but performance may vary based on your plan and usage patterns.
**Q: Can I white-label my apps?** A: Custom branding options are available on business plans.
**Q: Do my apps work offline?** A: Basic functionality may work offline, but most features require an internet connection.
**Q: Can I get my app code?** A: Apps are hosted on Taskade's platform. For custom hosting needs, contact our enterprise team.
***
## Getting Support
**Multiple ways to get help:**
1. **Start with our guides and video tutorials** - Comprehensive documentation and video walkthroughs
2. **Email <support@taskade.com> with details** - Direct support from our technical team
3. **Browse our community showcase for examples** - See real apps built by other users for inspiration
**β‘οΈ Pro tip:** Ask Genesis itself for suggestions! Try prompts like "What features should I add to make this app better?" or "How can I improve the user experience?" Genesis can recommend enhancements tailored for your app.
**Still have questions?**
* **Browse our help center:** [taskade.com/learn/genesis](https://www.taskade.com/learn/genesis)
* **Email us:** <support@taskade.com>
* **Join the community:** [taskade.com/community](https://taskade.com/community)
**Ready to start building?** [Open Genesis in your workspace β](https://taskade.com)
***
## Living Software FAQ
**Understanding the paradigm shift from static apps to living systems.**
### What is Living Software?
Living software actively learns, adapts, and evolves based on usage patterns, user interactions, and environmental changes. Unlike traditional static software that requires manual updates, living software continuously improves its capabilities and intelligence.
### How is living software different from regular apps?
Traditional apps are static tools with fixed features and manual maintenance. Living systems are dynamic ecosystems that:
* Learn from every user interaction
* Adapt to changing business needs
* Connect insights across all components
* Evolve their capabilities over time
### What is Workspace DNA?
Workspace DNA is the fundamental architecture of living software, consisting of three interconnected layers: Living Memory, Living Intelligence, and Living Motion. This trinity enables systems that think, learn, and act intelligently.
### How do AI agents become "living"?
AI agents become living through continuous learning from interactions, context awareness, and adaptation to user needs. They improve with every conversation and task.
### How do automations become "living"?
Living automations learn from success patterns, adapt timing and conditions, and continuously optimize performance based on real-world results.
### What are Living Systems?
Living Systems are complete business solutions that combine the three DNA layers into cohesive, evolving ecosystems. Unlike static applications, they grow more valuable with use.
### How do I build a living system?
Describe your needs in natural language using Genesis, and the system automatically creates a complete living solution with memory, intelligence, and motion layers working together.
### Can living systems work together?
Yes! Living systems share intelligence and learn from each other. A customer feedback system can inform inventory management, which can trigger marketing automations.
### Do I need to rebuild my existing workflows?
No! Living systems can enhance and evolve your existing processes. You can start with simple automations and gradually add intelligence and memory layers.
### Is living software more expensive?
Living software provides better ROI through continuous improvement and reduced maintenance. Systems that learn and adapt require less manual intervention over time.
### How do I get started with living software?
Start with Genesis to build your first living system, or explore AI Kits for ready-to-deploy solutions. The Workspace DNA foundation works with your existing tools.
### What business benefits do living systems provide?
Living systems deliver continuous improvement, predictive capabilities, scalable intelligence, adaptive resilience, and operational excellence.
### Can living systems handle compliance and security?
Yes! Living systems can be designed with enterprise-grade security, compliance features, and governance controls that evolve with regulatory requirements.
### How will living software evolve?
Future living systems will feature more sophisticated learning algorithms, deeper cross-system intelligence sharing, advanced predictive capabilities, and seamless human-AI collaboration.
**Living software represents the next evolution of business systems - from tools that humans use to intelligent partners that work alongside us.**
# Troubleshooting
Fix a Taskade Genesis app that missed the mark: sharpen prompts, add missing features, match your brand, connect integrations, and resolve context-limit errors.
Building with AI is like explaining your business to a really smart assistant who wants to help but sometimes needs more details. Don't worry if your first app isn't perfect - that's completely normal! Think of it as refining your idea until Taskade Genesis understands exactly what you need.
## Why Things Go Sideways
Before diving into fixes, let's understand why Genesis might miss the mark:
### Common Reasons Apps Miss the Mark
**β "I assumed Genesis would know my business"**
* Genesis is smart, but it doesn't know that your yoga studio focuses on beginners or that your restaurant is fast-casual
* Solution: Explain your business type and what makes it unique
**β "I asked for features instead of describing my problem"**
* Saying "I need a booking system" doesn't tell Genesis why customers currently struggle
* Solution: Explain the real problem - "Customers call during busy hours to book, interrupting service"
**β "I forgot to mention who will use this"**
* An app for tech-savvy millennials needs different design than one for elderly customers
* Solution: Describe your typical customer and how they prefer to interact
**β "I was too vague about what I wanted"**
* "Make it look professional" could mean corporate, medical, artistic, or trendy
* Solution: Be specific - "Clean and medical-looking for our dental practice"
## Get Back on Track
**Problem:** "I asked for a booking system and got... something else entirely"
This usually means Genesis needed more context about your specific business.
### How to Fix It
**Start by explaining the real-world problem you're solving:**
β **Too vague:** "I need a booking system"
β
**Much better:** "I run a massage therapy practice where clients need to book 60 or 90-minute sessions with specific therapists. Clients should see available time slots, pay a deposit through Stripe, and get confirmation emails. We also need to block out lunch breaks and handle last-minute cancellations."
### The Magic Formula
**Who + What + When + Why = Better Results**
```
[Who] needs to [What] because [Why], and it should [When/How]
```
**Examples:**
```
"Busy parents need to quickly book birthday party packages because they're planning last-minute, and it should show available dates, party themes, and total pricing upfront so they can decide immediately."
"Remote team members need to reserve conference rooms because we're back in the office 2 days a week, and it should prevent double-bookings, send calendar invites, and remind people 15 minutes before their meeting."
```
π‘ **Pro tip:** Pretend you're explaining your business to someone who's never worked in your industry. That level of detail will get Genesis on the right track.
## Add Missing Features
**Problem:** Genesis built exactly what you asked for, but you forgot something important.
This happens when we focus on the main feature and miss supporting processes.
### How to Fix It
**Walk through the complete user journey from start to finish:**
1. What happens **before** someone uses your main feature?
2. What needs to happen **during** the main interaction?
3. What should happen **afterward**?
**Example: Contact Form Missing File Uploads**
```
"The contact form looks great, but I also need clients to upload project briefs and reference materials when they submit requests. Add a secure file upload section that accepts PDFs and images up to 10MB."
```
**Example: Booking System Missing Cancellation Policy**
```
"The booking system works well, but I need to add our cancellation policy. Customers should be able to cancel up to 24 hours before their appointment, and cancellations within 24 hours should charge a 50% fee. Send confirmation emails for all cancellations."
```
π‘ **Think like your users:** What would frustrate them if it was missing? What would make their experience smooth and complete?
## Build On Brand
**Problem:** Your app looks generic and could belong to any business.
Generic-looking apps don't inspire trust or excitement.
### How to Fix It
**Describe your business personality in simple terms:**
**For a yoga studio:**
```
"We're a yoga studio, so make it feel calm and zenβsoft colors like sage green and cream, rounded corners, and peaceful vibes. Use gentle language like 'find your session' instead of 'book appointment'."
```
**For a fitness gym:**
```
"We're a high-energy fitness gym, so make it feel motivatingβbold colors like orange and black, strong typography, and action-oriented language like 'crush your workout' and 'claim your spot'."
```
**For a law firm:**
```
"We're a family law firm, so keep it professional but approachableβnavy blue and gray colors, clean lines, and trustworthy messaging that makes people feel supported during difficult times."
```
### Brand Elements to Specify
* **Colors:** Use specific hex codes if you have them
* **Tone:** Professional, friendly, energetic, calming, etc.
* **Language style:** Formal, casual, technical, simple
* **Visual style:** Clean, bold, minimal, detailed
* **Logo placement:** Where and how prominent
π‘ **Don't just say "make it look professional."** Tell Genesis what professional means for your specific business and audience.
## Connect Integrations
**Problem:** Your integrations aren't working as expected.
Integration issues usually come down to unclear instructions about data flow.
### How to Fix It
**Be specific about what information goes where and when:**
β **Too vague:** "Connect this to Slack"
β
**Clear and actionable:** "When someone submits the contact form, send a message to our #leads Slack channel with the person's name, email, and which service they're interested in. Include a link to their full submission."
### Integration Checklist
**For each integration, specify:**
1. **Trigger:** What event starts the integration?
2. **Data:** What specific information should be sent?
3. **Destination:** Where exactly should it go?
4. **Format:** How should the information be presented?
5. **Timing:** When should this happen?
**Example: CRM Integration**
```
"When someone books an appointment, automatically create a new contact in our HubSpot CRM with their name, email, phone, service booked, and appointment date. Tag them as 'New Client' and assign them to the team member who will provide their service."
```
π‘ **Test with real accounts:** Use your actual Slack workspace, email address, and CRM system, not dummy accounts. This helps catch permission issues early.
## Speed Things Up
**Problem:** Your app loads too slowly or feels sluggish.
Speed issues usually come from trying to do too much at once.
### Common Performance Problems
* **Large images** that take forever to load
* **Too many items** displayed on one screen
* **Heavy animations** that make scrolling choppy
* **Complex layouts** with lots of competing elements
### How to Fix It
**Prioritize what users need to see first:**
```
"Make this load faster by showing the booking calendar first, then loading the service descriptions and pricing in the background. Most people just want to see available times right away."
```
**Optimize heavy content:**
```
"The homepage is loading too slowly because of all those high-resolution photos. Compress the images and only show 3-4 key services upfront, with a 'See More' button for the rest."
```
**Simplify complex dashboards:**
```
"Simplify the dashboard by showing just the essential metrics firstβrevenue, bookings, and alerts. Move the detailed charts and reports to a separate tab so the main view loads instantly."
```
π‘ **Genesis can optimize automatically:** Just say "make this faster" and it will identify the biggest performance bottlenecks.
## Start Fresh
Sometimes it's faster to rebuild than keep patching. Consider starting over if:
* You've made **multiple major change requests** and it still doesn't feel right
* You **learned something fundamental** about your users that changes everything
* The app became **overly complex** while trying to fix multiple issues
* You realized you need a **completely different type** of solution
### How to Start Over Successfully
1. **Write down everything you learned** from the first attempt
2. **Create a much more detailed prompt** using those insights
3. **Include specific examples** of what should and shouldn't happen
4. **Reference other apps:** "Like the booking flow on \[website], but simpler"
**Starting over isn't failure** - it's using valuable learning to build something better.
## Common Error Messages
### "Context Limit Exceeded"
**Error message:**
```
"input length and `max_tokens` exceed context limit: 197180 + 8192 > 200000"
```
**What it means:** Your prompt or changes are too large for the AI to handle in one go.
**Why it happens:**
* Your prompt is extremely detailed (which is usually good, but can be too much)
* You're trying to change too many things at once
* The app has become very complex with lots of features
**How to fix it:**
1. **Click "Fix me"** to retry the prompt automatically
2. **Break your request into smaller pieces:**
```
Instead of: "Change the colors, add file uploads, connect to Slack, update the layout, and add a payment system"
Try: "First, let's change the colors to match our brand: blue (#1e40af) and white"
```
3. **Use simpler language:**
```
Instead of: "Implement a comprehensive customer relationship management system with advanced analytics..."
Try: "Add a simple way to track customer information and see which services they prefer"
```
### "Generation Failed"
**What it means:** Something went wrong during the app creation process.
**How to fix it:**
1. **Check your internet connection**
2. **Try a simpler version** of your prompt first
3. **Refresh the page** and try again
4. **Contact support** if it keeps happening
### "Integration Error"
**What it means:** Genesis couldn't connect to an external service.
**How to fix it:**
1. **Check your account permissions** for the service you're trying to connect
2. **Make sure you're using the correct account** (not a personal account for business integrations)
3. **Try connecting manually** first to test the integration
4. **Simplify the integration** and add complexity later
## When to Get Help
### Self-Service First
**Ask Genesis itself for help:**
```
"This booking system isn't quite right for my massage therapy business. What features should I add to make it work better for clients booking wellness appointments?"
"How can I improve the user experience for people submitting customer feedback on mobile devices?"
"What integrations would be most useful for a restaurant feedback app?"
```
### Contact Support
**Email** [**support@taskade.com**](mailto:support@taskade.com) **when:**
* You've tried multiple approaches and nothing works
* You're getting consistent error messages
* You need help with account or billing issues
* You want to integrate with a service that's not listed
**Include in your support request:**
* **What you're trying to build** (copy your prompt)
* **What you expected** to happen
* **What actually happened** (include screenshots if helpful)
* **Your app URL** if you need help with a specific issue
### Community Help
**Join the community** for:
* **Inspiration** from other users' creations
* **Tips and tricks** for better prompts
* **Industry-specific advice** from other business owners
* **Collaboration opportunities** on bigger projects
***
## Quick Troubleshooting Checklist
When your app isn't working as expected, try this checklist:
* [ ] **Is my prompt specific enough?** (Industry, users, business rules)
* [ ] **Did I explain the complete user journey?** (Before, during, after)
* [ ] **Am I testing with real data?** (Actual email addresses, real scenarios)
* [ ] **Have I described my brand personality?** (Colors, tone, style)
* [ ] **Are my integration instructions clear?** (What data goes where and when)
* [ ] **Am I trying to change too many things at once?** (Make one change at a time)
**Remember:** Every "failed" attempt teaches Genesis more about your business. Use what you learn to make your next prompt even better!
***
**Still stuck?** The AI agent in Genesis is always available to help troubleshoot issues and suggest improvements. Just describe what's not working and ask for specific help!
# Developer Platform
Everything you need to build on Taskade β REST API v1, Action API v2, OAuth 2.0, signed webhooks, and local + hosted MCP servers.
You want to integrate Taskade into your app, automate your workflows, or connect your AI tools. This page gets you started fast. Many teams build their app visually with [Taskade Genesis](https://www.taskade.com/create) first, then extend it with the API.
## Integration Surface at a Glance
```mermaid
graph TB
subgraph "Your Application"
APP["Your App / Script / Agent"]
end
subgraph "Integration Surface"
API1[REST API v1<br/>RESTful + OAuth 2.0]
API2[Action API v2<br/>RPC + OAuth 2.0]
MCP_IN["@taskade/mcp-server<br/>Inbound MCP, npm"]
MCP_HOST[Hosted MCP<br/>https://www.taskade.com/mcp]
MCP_OUT[MCP Connectors<br/>Outbound to 31+ services]
WEBHOOK[Webhooks<br/>Automation triggers]
end
subgraph "Taskade Workspace"
PROJECTS["Projects & Tasks"]
AGENTS["AI Agents<br/>with LTM"]
AUTOMATIONS[Automations]
MEDIA["Media & Bundles"]
APP_SRC["Taskade Genesis App Source"]
end
APP --> API1
APP --> API2
APP --> MCP_IN
APP --> MCP_HOST
WEBHOOK --> APP
MCP_IN --> API1
MCP_HOST --> APP_SRC
MCP_OUT --> AGENTS
API1 --> PROJECTS
API1 --> AGENTS
API2 --> AGENTS
API2 --> MEDIA
API1 --> AUTOMATIONS
AGENTS -.writes LTM.-> PROJECTS
```
## I Want To...
| I want to... | Use |
| ------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
| Write tasks, manage assignees/dates/fields (full CRUD) | [REST API v1](/developers/comprehensive-api-guide) |
| Prompt agents, manage agents, export/import bundles | [Action API v2](/developers/api-v2-reference) |
| Hit endpoints from any language | [REST API v1](/developers/comprehensive-api-guide) + [Action API v2](/developers/api-v2-reference) |
| Expose Taskade data to Claude Desktop, Cursor, or other MCP clients | [Workspace MCP](/developers/workspace-mcp) + [Advanced](/developers/workspace-mcp/workspace-mcp-advanced) |
| Give a Taskade agent third-party capabilities | [MCP Connectors](/developers/mcp-connectors) |
| Edit Taskade Genesis app source code from your IDE | [Hosted MCP (Genesis App)](/developers/workspace-mcp/genesis-app-mcp) |
| Receive real-time events in your app | [Webhooks](/developers/webhooks) |
| Understand long-term memory | [Long-Term Memory](/developers/long-term-memory) |
| Build agents that run without prompting | [Autonomous Agents](/developers/autonomous-agents) |
| Automate workflows without code | [Automations Engine](/automations/automation) |
| Browse community apps and templates | [taskade.com/community](https://www.taskade.com/community) |
## Get Your API Key
You need a **Personal Access Token** to authenticate with every Taskade developer tool β the REST API, MCP Server, and SDK all use it.
1. Go to [taskade.com/settings/api](https://www.taskade.com/settings/api).
2. Click **Create new token** and give it a descriptive name.
3. Copy the token and store it somewhere safe. You will not be able to see it again.
{% hint style="warning" %}
Treat your API token like a password. Never commit it to version control or share it publicly.
{% endhint %}
## Developer Resources
| Resource | Description |
| ---------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [REST API v1 Reference](/developers/comprehensive-api-guide) | The complete, stable RESTful API β full task CRUD, per-endpoint docs |
| [Action API v2 Reference](/developers/api-v2-reference) | The newer action-based (RPC) API β agent prompting, bundles, lifecycle |
| [Authentication Guide](/developers/authentication) | Personal access tokens and OAuth 2.0 (PKCE) flows |
| [Workspace MCP](/developers/workspace-mcp) | Run `@taskade/mcp-server` to connect Claude Desktop, Cursor, and Claude Code ([source](https://github.com/taskade/mcp)) |
| [Workspace MCP β Advanced](/developers/workspace-mcp/workspace-mcp-advanced) | Multi-client setup, troubleshooting, security |
| [Hosted Taskade MCP (Beta)](/developers/workspace-mcp/genesis-app-mcp) | Orchestrate your workspace from your IDE β create projects, manage & prompt agents, and edit your Genesis app's source via the remote `https://www.taskade.com/mcp` server |
| [MCP Connectors](/developers/mcp-connectors) | Give Taskade agents 31+ third-party tools (outbound MCP) |
| [Integration Kit (GitHub)](https://github.com/taskade/integrations) | Open-source Zapier and n8n actions & triggers built on the public API β contribute or self-host |
| [Webhooks](/developers/webhooks) | Trigger automations from external events; call out to any API |
| [Bundles & App Kits](/developers/bundles) | Import/export full Genesis apps as portable `.tsk` bundles |
| [Long-Term Memory](/developers/long-term-memory) | Memory-as-Projects architecture β editable, queryable, API-addressable |
| [Autonomous Agents](/developers/autonomous-agents) | Automations, orchestration, cross-agent invocation patterns |
| [TypeScript SDK (Preview)](/developers/sdk-quickstart) | Generated client for v2 β not yet on public npm; use the REST API meanwhile |
{% hint style="info" %}
**New to Taskade?** Start with the [Quick Start Guide](/quick-start/getting-started) to understand workspaces, projects, and tasks before diving into the API.
{% endhint %}
## Base URLs
Taskade ships **two** public HTTP APIs, both authenticated with the same token:
| API | Base URL | Style | Use it for |
| -------------------------------------------------- | -------------------------------- | ------------------------------------- | ----------------------------------------------- |
| [REST API v1](/developers/comprehensive-api-guide) | `https://www.taskade.com/api/v1` | RESTful (`GET`/`POST`/`PUT`/`DELETE`) | Full task CRUD, assignees, dates, notes, fields |
| [Action API v2](/developers/api-v2-reference) | `https://www.taskade.com/api/v2` | Action / RPC (`POST /{operation}`) | Prompting agents, agent lifecycle, bundles |
{% hint style="info" %}
**Live OpenAPI specs (source of truth)** β auto-generated from the running API, always current:
* REST API v1 β [interactive docs](https://www.taskade.com/api/documentation/v1) Β· [openapi.json](https://www.taskade.com/api/documentation/v1/json)
* Action API v2 β [interactive docs](https://www.taskade.com/api/documentation/v2) Β· [openapi.json](https://www.taskade.com/api/documentation/v2/json)
The reference pages in this guide are hand-written companions (examples, patterns, best practices). When in doubt about an exact field or status code, the live spec wins.
{% endhint %}
Include your token in the `Authorization` header:
```bash
# v1 (RESTful)
curl -H "Authorization: Bearer your_api_key_placeholder" \
https://www.taskade.com/api/v1/me/projects
# v2 (action-based β every call is a POST)
curl -X POST https://www.taskade.com/api/v2/listMyProjects \
-H "Authorization: Bearer your_api_key_placeholder" \
-H "Content-Type: application/json" -d '{}'
```
## Errors
Both APIs return a consistent JSON error envelope β expected failures come back as typed errors, not bare `500`s:
```json
{ "ok": false, "code": "PAYMENT_REQUIRED", "message": "Webhooks require a Pro plan or higher." }
```
The HTTP status matches the `code` (e.g. `401` `UNAUTHORIZED`, `402` `PAYMENT_REQUIRED`, `403` `FORBIDDEN`, `404` `NOT_FOUND`, `429` `TOO_MANY_REQUESTS`). Branch on `ok` and `code` rather than parsing `message`.
## What You Can Build
* **Custom dashboards** that pull data from Taskade workspaces and projects
* **CI/CD integrations** that create tasks or update statuses on deploy
* **AI assistants** that manage tasks and agents through the MCP Server
* **Internal tools** that connect Taskade to your company's systems
* **Automation bots** that react to events and keep projects in sync
{% hint style="success" %}
**Need help?** Join the [Taskade community](https://www.taskade.com/community) or reach out to support at [taskade.com/contact](https://www.taskade.com/contact).
{% endhint %}
# Developer Overview
Build on Taskade with the REST API, OAuth 2.0 and personal tokens, MCP server, webhooks, and Genesis app generation, agents, and automation.
**Build on Taskade's platform for applications, agents, and automation.**
{% hint style="info" %}
**New to Taskade's API?** Start with [Personal Tokens](/developers/authentication/personal-tokens) (fast) or [Authentication (OAuth 2.0)](/developers/authentication), then use the [API documentation](https://www.taskade.com/api/documentation/).
{% endhint %}
## Platform Overview
Taskade provides a complete platform for building intelligent applications:
| Capability | Description | Learn More |
| ----------------------- | ------------------------------------------------------ | ------------------------------------------------------------------------------- |
| **AI App Builder** | Generate full-stack applications from natural language | [Taskade Genesis β](/taskade-genesis/genesis) |
| **AI Agents Platform** | Custom assistants with knowledge retrieval | [AI Agents Guide β](https://www.taskade.com/learn/agents/custom-agents) |
| **Workflow Automation** | Event-driven processing with 100+ integrations | [Automations β](https://www.taskade.com/learn/automation/automations-execution) |
| **Projects & Data** | Structured data with real-time sync and custom fields | [Projects Guide β](https://www.taskade.com/learn/projects/databases) |
The API is built around real-time data synchronization and a unified intelligence layer that powers everything from simple CRUD operations to complex AI-driven workflows.
## Quick Start
{% tabs %}
{% tab title="First API Call" %}
#### Start with a Personal Access Token
Set up your development environment, get API keys, and make your first request in under 5 minutes.
```bash
curl -H "Authorization: Bearer YOUR_API_KEY" \
https://www.taskade.com/api/v1/workspaces
```
Get a token here: [Personal Tokens](/developers/authentication/personal-tokens).
{% endtab %}
{% tab title="Authentication" %}
#### OAuth 2.0 (production)
Use OAuth when you need user-based auth and scoped access.
**Supported methods:**
* Personal Access Tokens (recommended for development)
* OAuth 2.0 (recommended for production): [Authentication](/developers/authentication)
{% endtab %}
{% tab title="SDKs & Tools" %}
#### **SDKs & Libraries**
Official libraries and tools:
**Official:**
* `@taskade/sdk` -- TypeScript SDK (Preview β not yet on public npm) ([Quickstart](/developers/sdk-quickstart))
* [@taskade/mcp-server](https://github.com/taskade/mcp) -- Workspace MCP Server for Claude, Cursor, Claude Code ([Setup Guide](/developers/workspace-mcp))
* Hosted Taskade MCP (Beta) -- orchestrate your workspace and edit Genesis app source from your IDE ([Setup Guide](/developers/workspace-mcp/genesis-app-mcp))
* REST API with OpenAPI spec
* Webhook integrations
**Resources:**
* [Autonomous Agents Guide](/developers/autonomous-agents) -- Agent use cases and architecture patterns
* [Community Apps](https://www.taskade.com/community) -- Browse Genesis apps built by the community
* [Sample App](https://github.com/taskade/taskade-sample-app) -- Genesis app example
* [Integration Kit](https://github.com/taskade/integrations) -- Open-source Zapier & n8n actions and triggers built on the public API
{% endtab %}
{% endtabs %}
## Core APIs
### [**Workspaces & Projects**](/developers/comprehensive-api-guide/workspaces)
**Tree-structured data with real-time synchronization**. Projects support conflict-free collaborative editing with instant synchronization across all connected clients. Each project maintains versioned change history for reliable collaboration.
### [**Tasks & Data**](/developers/comprehensive-api-guide/tasks)
**Event-sourced task management with rich field types**. Tasks support complex data relationships, custom field schemas, and atomic batch operations. The system maintains audit trails and supports time-travel queries for debugging and analytics.
### [**AI Agents**](/developers/comprehensive-api-guide/agents)
**Stateful AI agents with persistent memory and tool access**. Each agent maintains its own knowledge graph derived from project data, documents, and conversation history. Agents can be composed into multi-agent workflows with dependency resolution and error handling.
## Automations & Integrations
### [**Automation System**](/automations/automation)
**Event-driven architecture with guaranteed delivery**. Built on a distributed event system for reliable message processing. Supports exactly-once delivery semantics, failure handling, and automatic retry with exponential backoff.
### [**Action & Trigger Reference**](/automations/automation/actions)
**Reactive programming model with high reliability**. Triggers provide real-time event detection and processing. Actions include robust error handling and timeout patterns for reliable external service integration.
### [**Integration Reference**](/automations/automation/comprehensive-integrations)
**100+ pre-built connectors with OpenAPI 3.0 compliance**. Each integration includes rate limiting, authentication handling, and automatic schema validation. Custom integrations support GraphQL subscriptions and WebSocket streaming.
## Genesis API
### [**Taskade Genesis**](/taskade-genesis/genesis)
Build complete web applications from natural language prompts. Taskade Genesis handles code generation and automatic deployment.
[**Create Your First App β**](https://www.taskade.com/learn/genesis/first-app)
## Resources
### [**OpenAPI Specification**](https://www.taskade.com/api/documentation/v1)
Interactive API documentation with live testing capabilities.
### [**API Guide**](/developers/comprehensive-api-guide/api)
Official and community-maintained libraries for popular languages.
### [**API Best Practices**](/developers/comprehensive-api-guide/api#best-practices)
**Performance characteristics and scaling guidelines**. The platform is built for high-throughput applications with enterprise-grade performance. Rate limits are implemented to ensure fair usage across all users. Includes guidance on connection pooling, request batching, and optimal retry strategies.
## Community & Support
| Resource | Description |
| ------------------------------------------------------------------- | --------------------------------------------- |
| [**API Documentation**](https://www.taskade.com/api/documentation/) | Interactive API documentation (Swagger) |
| [**Community Forum**](https://www.taskade.com/community) | Developer discussions, integration sharing |
| [**GitHub Repository**](https://github.com/taskade/docs) | Documentation contributions, feature requests |
| [**Status Page**](https://taskade.statuspage.io) | API uptime, service announcements |
| [**Community Apps**](https://www.taskade.com/community) | Browse apps built with Taskade |
***
**Ready to start building?**
π [**Get a Personal Token β**](/developers/authentication/personal-tokens)\
π [**API Documentation β**](https://www.taskade.com/api/documentation/)\
π¬ [**Join Developer Community β**](https://www.taskade.com/community)
# Authentication
How to authenticate with every Taskade developer surface β Personal Access Tokens for scripts and MCP, OAuth 2.0 with PKCE for third-party apps.
Every Taskade developer surface β the [REST API v1](/developers/comprehensive-api-guide), the [Action API v2](/developers/api-v2-reference), and the [MCP servers](/developers/workspace-mcp) β authenticates with a **Bearer token**. There are two kinds you can create.
## Which credential should I use?
| If you are⦠| Use | How |
| --------------------------------------------------------------------------------- | ----------------------------------------- | --------------------------------------- |
| Writing a script, or using the SDK / CLI / inbound `@taskade/mcp-server` | **Personal Access Token** | `Authorization: Bearer tskdp_β¦` |
| Building a third-party app that acts on behalf of other users | **OAuth 2.0** (Authorization Code + PKCE) | Redirect flow |
| Connecting Claude / Cursor to the **hosted** MCP at `https://www.taskade.com/mcp` | **OAuth 2.0** | Handled automatically by the MCP client |
***
## Personal Access Tokens
The simplest way to authenticate as yourself. Best for server-to-server scripts, the inbound MCP server, and getting started.
### Create a token
1. Go to [taskade.com/settings/api](https://www.taskade.com/settings/api).
2. Click **Create new token** and give it a descriptive name.
3. Copy the token immediately β it is shown **only once**.
A personal access token starts with the prefix `tskdp_`. You can hold up to **5 tokens** per account, and your email must be verified to create one.
{% hint style="warning" %}
A personal access token grants **full access to your account**. Treat it like a password: never commit it to version control, never share it, and store it in an environment variable or secret manager.
{% endhint %}
### Use a token
Send it in the `Authorization` header on every request:
```bash
# REST API v1
curl -H "Authorization: Bearer tskdp_your_token" \
https://www.taskade.com/api/v1/me/projects
# Action API v2
curl -X POST https://www.taskade.com/api/v2/listMyProjects \
-H "Authorization: Bearer tskdp_your_token" \
-H "Content-Type: application/json" -d '{}'
```
The inbound MCP server reads it from the `TASKADE_API_KEY` environment variable β see [Workspace MCP](/developers/workspace-mcp).
***
## OAuth 2.0
Use OAuth 2.0 when your application acts **on behalf of other users** (so each user signs in and grants access), or when connecting to the hosted MCP endpoint.
### Endpoints
| Purpose | URL |
| --------------------------- | ---------------------------------------------------------------- |
| Authorization | `https://www.taskade.com/oauth2/authorize` |
| Token / Refresh | `https://www.taskade.com/oauth2/token` |
| Dynamic client registration | `https://www.taskade.com/oauth2/register` |
| Server metadata (RFC 8414) | `https://www.taskade.com/.well-known/oauth-authorization-server` |
### Register an application
Go to [taskade.com/settings/api](https://www.taskade.com/settings/api) β **OAuth 2.0 Apps** and register your app to obtain a **Client ID** and **Client Secret**, and to set your redirect URI(s).
### Authorization Code flow (with PKCE)
Taskade supports the **Authorization Code** grant with **PKCE (S256)** β the recommended flow for both confidential and public clients.
```mermaid
sequenceDiagram
participant App as Your App
participant Taskade as www.taskade.com
participant User as End User
App->>Taskade: GET /oauth2/authorize?client_id&redirect_uri&code_challenge&scope
Taskade->>User: Show consent screen
User->>Taskade: Approve
Taskade->>App: Redirect with authorization code
App->>Taskade: POST /oauth2/token (code + code_verifier)
Taskade->>App: access_token (1 hour) + refresh_token
App->>Taskade: API request with Bearer access_token
```
1. **Redirect** the user to `/oauth2/authorize` with `client_id`, `redirect_uri`, `response_type=code`, a PKCE `code_challenge` (and `code_challenge_method=S256`), and any `scope`.
2. **Exchange** the returned `code` at `/oauth2/token` (`grant_type=authorization_code`) along with your `code_verifier`. Confidential apps also send `client_secret`; public clients use PKCE only.
3. You receive an **`access_token`** (valid for **1 hour**) and a **`refresh_token`**.
**Generating the PKCE pair** (the step most implementations get wrong):
```bash
# code_verifier: a high-entropy random string
code_verifier=$(openssl rand -base64 96 | tr -d '\n=+/' | cut -c1-64)
# code_challenge = BASE64URL( SHA256(code_verifier) )
code_challenge=$(printf '%s' "$code_verifier" \
| openssl dgst -binary -sha256 \
| openssl base64 | tr -d '=\n' | tr '+/' '-_')
```
Send `code_challenge` (with `code_challenge_method=S256`) on the authorize request, then send the original `code_verifier` on the token exchange below.
```bash
curl -X POST https://www.taskade.com/oauth2/token \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "grant_type=authorization_code" \
-d "code=AUTH_CODE" \
-d "code_verifier=PKCE_VERIFIER" \
-d "client_id=YOUR_CLIENT_ID" \
-d "redirect_uri=YOUR_REDIRECT_URI"
```
### Refresh an expired token
Access tokens expire after one hour. Exchange the stored refresh token for a new one:
```bash
curl -X POST https://www.taskade.com/oauth2/token \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "grant_type=refresh_token" \
-d "refresh_token=YOUR_REFRESH_TOKEN" \
-d "client_id=YOUR_CLIENT_ID"
```
{% hint style="info" %}
Only `authorization_code` and `refresh_token` grants are supported. `password`, `implicit`, and `client_credentials` are rejected.
{% endhint %}
### Scopes & the hosted MCP
The hosted MCP server at [https://www.taskade.com/mcp](/developers/workspace-mcp/genesis-app-mcp) requires an OAuth token carrying the **`mcp`** scope. MCP clients (Claude Desktop, Cursor, Claude Code) perform this OAuth handshake β including dynamic client registration β automatically when you add the server URL, so you normally don't implement it yourself.
***
## Security Best Practices
* **Never expose tokens in client-side code.** Personal tokens grant full account access.
* **Use OAuth, not personal tokens,** for any app used by more than one person.
* **Store refresh tokens encrypted at rest** β they're long-lived.
* **Rotate personal tokens** periodically; you can keep up to 5 active.
* **Always use HTTPS.**
## Related
{% content-ref url="/pages/hT6ytQBZHuGOKYlzA7Hp" %}
[Personal Tokens](/developers/authentication/personal-tokens)
{% endcontent-ref %}
{% content-ref url="/pages/gAVvLQJwpYMggTbXn18Q" %}
[Action API v2 Reference](/developers/api-v2-reference)
{% endcontent-ref %}
# Personal Tokens
Generate a Taskade Personal Access Token and authenticate API requests with the Authorization Bearer header. Simpler than full OAuth 2.0.
Authentication is a crucial aspect of ensuring the security and integrity of your interactions with our API. We provide two distinct methods for authentication.
## Overview
Personal Access Tokens are unique strings that represent your authorization to access our API. They are designed for simple use-cases and for instances where full OAuth 2.0 flow might be unnecessary or too complex.
## Steps to Obtain and Use a Personal Access Token:
1. **Generate a Token:**
* Navigate to <https://www.taskade.com/settings/api> and scroll down to **Personal Access Tokens**.
* Follow the on-screen instructions to create your personal access token.
2. **Using the Token in API Requests:**
* Once you have your token, include it in the header of your API requests. Typically, this is done using the `Authorization` header. For example:
```makefile
Authorization: Bearer YOUR_PERSONAL_ACCESS_TOKEN
```
3. **Note:** Treat your personal access tokens with care. They are like passwords β anyone who has the token can access the API on your behalf. If you believe a token has been compromised, regenerate a new one immediately.
# REST API v1 Reference
Taskade REST API v1 reference β authenticate, then manage workspaces, projects, tasks, agents, folders, and media with full CRUD and copy-paste code examples.
Build powerful integrations with Taskade's REST API. Access projects, tasks, agents, and more programmatically with full CRUD operations.
{% hint style="success" %}
Taskade's API provides programmatic access to core platform features. Whether you're building custom integrations or automating workflows, our RESTful API offers the flexibility you need.
{% endhint %}
## API Overview
The Taskade API is a RESTful web service that provides programmatic access to Taskade features.
### Key Features
* **RESTful Design**: Standard HTTP methods and status codes
* **Secure Authentication**: OAuth 2.0 and Personal Access Token authentication
* **Complete CRUD Operations**: Full create, read, update, delete functionality
* **Comprehensive Documentation**: Detailed endpoint documentation
### API Base URL
```
Base URL: https://www.taskade.com/api/v1
Authentication: Bearer token
Content-Type: application/json
```
## Authentication
### Personal Access Token Authentication
**Simple authentication for server-to-server applications:**
```bash
# Using Personal Access Token in header
curl -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
https://www.taskade.com/api/v1/workspaces
```
#### Obtaining a Personal Access Token
1. Go to [taskade.com/settings/api](https://www.taskade.com/settings/api).
2. Click **Create new token** and give it a descriptive name.
3. Copy and securely store your token β it starts with the `tskdp_` prefix (you can hold up to 5 tokens per account).
4. Use the token in the `Authorization` header.
See the [Authentication](/developers/authentication) guide for OAuth 2.0 and full details.
### OAuth 2.0 Authentication
**Secure authentication for user-facing applications:**
```bash
# Authorization URL
https://www.taskade.com/oauth2/authorize
# Token URL
https://www.taskade.com/oauth2/token
```
## Core API Resources
{% hint style="info" %}
**Looking for bundle export/import?** The four `/bundles/*` endpoints (export or import a Genesis app as a portable bundle) are documented on the [Bundles & App Kits](/developers/bundles) page.
{% endhint %}
### Workspaces API
**Manage workspaces and their contents:**
#### Get All Workspaces
```bash
GET /workspaces
```
```javascript
// JavaScript example
const getWorkspaces = async (token) => {
const response = await fetch('https://www.taskade.com/api/v1/workspaces', {
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
}
});
return response.json();
};
```
```python
# Python example
import requests
def get_workspaces(token):
headers = {
'Authorization': f'Bearer {token}',
'Content-Type': 'application/json'
}
response = requests.get('https://www.taskade.com/api/v1/workspaces', headers=headers)
return response.json()
```
#### Get Workspace Folders
```bash
GET /workspaces/{workspaceId}/folders
```
#### Create Project in Workspace
```bash
POST /workspaces/{workspaceId}/projects
Content-Type: application/json
{
"contentType": "text/markdown",
"content": "# My New Project\n\n- Task 1\n- Task 2"
}
```
### Folders API
**Manage folders (subspaces) and their contents:**
#### Get Folder Projects
```bash
GET /folders/{folderId}/projects
```
#### Get Folder Agents
```bash
GET /folders/{folderId}/agents
```
#### Create Agent in Folder
```bash
POST /folders/{folderId}/agents
Content-Type: application/json
{
"name": "Customer Support Agent",
"data": {
"type": "template",
"template": {
"type": "CustomerSupport"
}
}
}
```
#### Generate Agent with AI
```bash
POST /folders/{folderId}/agent-generate
Content-Type: application/json
{
"text": "Create an agent that helps with customer support questions"
}
```
#### Get Folder Media Files
```bash
GET /folders/{folderId}/medias
```
#### Get Folder Project Templates
```bash
GET /folders/{folderId}/project-templates
```
### Projects API
**Comprehensive project management:**
#### Get Project
```bash
GET /projects/{projectId}
```
#### Create Project
```bash
POST /projects
Content-Type: application/json
{
"folderId": "folder_123",
"contentType": "text/markdown",
"content": "# Project Title\n\n- First task\n- Second task"
}
```
#### Complete Project
```bash
POST /projects/{projectId}/complete
```
#### Restore Project
```bash
POST /projects/{projectId}/restore
```
#### Copy Project
```bash
POST /projects/{projectId}/copy
Content-Type: application/json
{
"folderId": "destination_folder_id",
"projectTitle": "Copied Project Name"
}
```
#### Create Project from Template
```bash
POST /projects/from-template
Content-Type: application/json
{
"folderId": "folder_123",
"templateId": "template_456"
}
```
#### Get Project Members
```bash
GET /projects/{projectId}/members?limit=20&page=1
```
#### Get Project Fields
```bash
GET /projects/{projectId}/fields
```
#### Get Project Share Link
```bash
GET /projects/{projectId}/shareLink
```
#### Enable Share Link
```bash
PUT /projects/{projectId}/shareLink
```
#### Get Project Blocks
```bash
GET /projects/{projectId}/blocks?limit=100
```
#### Get Project Tasks
```bash
GET /projects/{projectId}/tasks?limit=100
```
### Tasks API
**Comprehensive task management:**
#### Get Task
```bash
GET /projects/{projectId}/tasks/{taskId}
```
#### Create Tasks
```bash
POST /projects/{projectId}/tasks/
Content-Type: application/json
{
"tasks": [
{
"contentType": "text/markdown",
"content": "New task content",
"placement": "beforeend"
}
]
}
```
```javascript
// Create multiple tasks
const createTasks = async (projectId, tasks) => {
const response = await fetch(
`https://www.taskade.com/api/v1/projects/${projectId}/tasks/`,
{
method: 'POST',
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
tasks: tasks.map(content => ({
contentType: 'text/markdown',
content: content,
placement: 'beforeend'
}))
})
}
);
return response.json();
};
```
#### Update Task
```bash
PUT /projects/{projectId}/tasks/{taskId}
Content-Type: application/json
{
"contentType": "text/markdown",
"content": "Updated task content"
}
```
#### Delete Task
```bash
DELETE /projects/{projectId}/tasks/{taskId}
```
#### Complete Task
```bash
POST /projects/{projectId}/tasks/{taskId}/complete
```
#### Mark Task Incomplete
```bash
POST /projects/{projectId}/tasks/{taskId}/uncomplete
```
#### Move Task
```bash
PUT /projects/{projectId}/tasks/{taskId}/move
Content-Type: application/json
{
"target": {
"taskId": "target_task_id",
"position": "afterend"
}
}
```
Position options: `beforebegin`, `afterbegin`, `beforeend`, `afterend`
#### Get Task Assignees
```bash
GET /projects/{projectId}/tasks/{taskId}/assignees
```
#### Update Task Assignees
```bash
PUT /projects/{projectId}/tasks/{taskId}/assignees
Content-Type: application/json
{
"handles": ["user_handle_1", "user_handle_2"]
}
```
#### Remove Task Assignee
```bash
DELETE /projects/{projectId}/tasks/{taskId}/assignees/{assigneeHandle}
```
#### Get Task Date
```bash
GET /projects/{projectId}/tasks/{taskId}/date
```
#### Set Task Date
```bash
PUT /projects/{projectId}/tasks/{taskId}/date
Content-Type: application/json
{
"start": {
"date": "2024-12-31",
"time": "17:00:00",
"timezone": "America/New_York"
},
"end": {
"date": "2025-01-15",
"time": "17:00:00",
"timezone": "America/New_York"
}
}
```
#### Delete Task Date
```bash
DELETE /projects/{projectId}/tasks/{taskId}/date
```
#### Get Task Note
```bash
GET /projects/{projectId}/tasks/{taskId}/note
```
#### Update Task Note
```bash
PUT /projects/{projectId}/tasks/{taskId}/note
Content-Type: application/json
{
"type": "text/markdown",
"value": "This is a note for the task"
}
```
#### Delete Task Note
```bash
DELETE /projects/{projectId}/tasks/{taskId}/note
```
#### Get Task Field Values
```bash
GET /projects/{projectId}/tasks/{taskId}/fields
```
#### Get Specific Field Value
```bash
GET /projects/{projectId}/tasks/{taskId}/fields/{fieldId}
```
#### Update Field Value
```bash
PUT /projects/{projectId}/tasks/{taskId}/fields/{fieldId}
Content-Type: application/json
{
"value": "field_value"
}
```
#### Delete Field Value
```bash
DELETE /projects/{projectId}/tasks/{taskId}/fields/{fieldId}
```
### Agents API
**Manage AI agents:**
#### Get Agent
```bash
GET /agents/{agentId}
```
#### Update Agent
```bash
PATCH /agents/{agentId}
Content-Type: application/json
{
"name": "Updated Agent Name",
"data": {
"description": "Updated agent description"
}
}
```
#### Delete Agent
```bash
DELETE /agents/{agentId}
```
#### Enable Public Access
```bash
PUT /agents/{agentId}/publicAccess
```
#### Get Public Agent Settings
```bash
GET /agents/{agentId}/public-agent
```
#### Update Public Agent Settings
```bash
PATCH /agents/{agentId}/public-agent
Content-Type: application/json
{
"preferences": {
"mode": "chatbot",
"theme": "light",
"hideBranding": false
}
}
```
#### Get Public Agent by Public ID
```bash
GET /public-agents/{publicAgentId}
```
#### Add Project to Agent Knowledge
```bash
POST /agents/{agentId}/knowledge/project
Content-Type: application/json
{
"projectId": "project_123"
}
```
#### Add Media to Agent Knowledge
```bash
POST /agents/{agentId}/knowledge/media
Content-Type: application/json
{
"mediaId": "media_456"
}
```
#### Remove Project from Agent Knowledge
```bash
DELETE /agents/{agentId}/knowledge/project/{projectId}
```
#### Remove Media from Agent Knowledge
```bash
DELETE /agents/{agentId}/knowledge/media/{mediaId}
```
#### Get Agent Conversations
```bash
GET /agents/{agentId}/convos/?limit=20&page=1
```
#### Get Specific Conversation
```bash
GET /agents/{agentId}/convos/{convoId}
```
### Media API
**Manage uploaded files:**
#### Get Media
```bash
GET /medias/{mediaId}
```
#### Delete Media
```bash
DELETE /medias/{mediaId}
```
### User Projects API
**Access the authenticated user's projects:**
#### Get My Projects
```bash
GET /me/projects?limit=100&page=1&sort=viewed-desc
```
Sort options: `viewed-asc`, `viewed-desc`
## Error Handling
### HTTP Status Codes
* **200 OK**: Request successful
* **400 Bad Request**: Invalid request parameters
* **401 Unauthorized**: Authentication required or invalid
* **403 Forbidden**: Insufficient permissions
* **404 Not Found**: Resource not found
* **4XX**: Client error (see response for details)
### Error Response Format
```json
{
"ok": false,
"message": "Error description",
"code": "ERROR_CODE",
"statusMessage": "HTTP status message"
}
```
### Error Handling Example
```javascript
// Robust error handling
const apiRequest = async (url, options = {}) => {
const response = await fetch(url, {
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json',
...options.headers
},
...options
});
const data = await response.json();
if (!data.ok) {
throw new Error(`API Error: ${data.message} (${data.code})`);
}
return data;
};
```
## Pagination
Many endpoints support pagination using cursor-based or page-based approaches:
### Page-based Pagination
```bash
GET /me/projects?limit=20&page=2
```
### Cursor-based Pagination (Tasks/Blocks)
```bash
# Get tasks after a specific task
GET /projects/{projectId}/tasks?limit=100&after={taskId}
# Get tasks before a specific task
GET /projects/{projectId}/tasks?limit=100&before={taskId}
```
## Code Examples
### Complete Workflow Example
```javascript
// Complete example: Create a project and add tasks
const createProjectWithTasks = async (folderId, projectName, tasks) => {
const headers = {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
};
// Step 1: Create the project
const projectContent = `# ${projectName}\n\n` +
tasks.map(t => `- ${t}`).join('\n');
const projectResponse = await fetch(
'https://www.taskade.com/api/v1/projects',
{
method: 'POST',
headers,
body: JSON.stringify({
folderId: folderId,
contentType: 'text/markdown',
content: projectContent
})
}
);
const projectData = await projectResponse.json();
if (!projectData.ok) {
throw new Error(`Failed to create project: ${projectData.message}`);
}
return projectData.item;
};
// Usage
const project = await createProjectWithTasks(
'folder_123',
'My New Project',
['Task 1', 'Task 2', 'Task 3']
);
console.log('Created project:', project.id);
```
### Agent Integration Example
```javascript
// Create an agent and add knowledge
const setupAgent = async (folderId, agentName, projectIds) => {
const headers = {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
};
// Step 1: Create the agent
const agentResponse = await fetch(
`https://www.taskade.com/api/v1/folders/${folderId}/agents`,
{
method: 'POST',
headers,
body: JSON.stringify({
name: agentName,
data: {
type: 'template',
template: {
type: 'Researcher'
}
}
})
}
);
const agentData = await agentResponse.json();
const agentId = agentData.item.id;
// Step 2: Add projects to knowledge base
for (const projectId of projectIds) {
await fetch(
`https://www.taskade.com/api/v1/agents/${agentId}/knowledge/project`,
{
method: 'POST',
headers,
body: JSON.stringify({ projectId })
}
);
}
return agentData.item;
};
```
### Python Example
```python
import requests
API_BASE = 'https://www.taskade.com/api/v1'
class TaskadeClient:
def __init__(self, token):
self.token = token
self.headers = {
'Authorization': f'Bearer {token}',
'Content-Type': 'application/json'
}
def get_workspaces(self):
"""Get all workspaces"""
response = requests.get(f'{API_BASE}/workspaces', headers=self.headers)
return response.json()
def get_folder_projects(self, folder_id):
"""Get all projects in a folder"""
response = requests.get(
f'{API_BASE}/folders/{folder_id}/projects',
headers=self.headers
)
return response.json()
def create_project(self, folder_id, content):
"""Create a new project"""
response = requests.post(
f'{API_BASE}/projects',
headers=self.headers,
json={
'folderId': folder_id,
'contentType': 'text/markdown',
'content': content
}
)
return response.json()
def complete_task(self, project_id, task_id):
"""Mark a task as complete"""
response = requests.post(
f'{API_BASE}/projects/{project_id}/tasks/{task_id}/complete',
headers=self.headers
)
return response.json()
def get_agent(self, agent_id):
"""Get an agent"""
response = requests.get(
f'{API_BASE}/agents/{agent_id}',
headers=self.headers
)
return response.json()
# Usage
client = TaskadeClient('YOUR_ACCESS_TOKEN')
workspaces = client.get_workspaces()
print(f"Found {len(workspaces['items'])} workspaces")
```
## Best Practices
### Security
* Store API tokens securely (environment variables, secret management)
* Use HTTPS for all API calls
* Implement proper error handling
* Never expose tokens in client-side code
### Performance
* Use pagination for large result sets
* Cache responses when appropriate
* Implement exponential backoff for retries
* Batch operations when possible
### Data Management
* Validate data before sending to API
* Handle partial failures gracefully
* Implement proper logging and monitoring
## Support and Resources
### Documentation
* **API Reference**: Full endpoint documentation in each resource section
* **Authentication Guide**: [Personal Access Tokens](/developers/authentication/personal-tokens)
* **OAuth Setup**: [OAuth Authentication](/developers/authentication)
### Getting Help
* **Support**: <support@taskade.com>
* **Help Center**: [taskade.com/learn](https://www.taskade.com/learn)
{% hint style="info" %}
**Need more help?** Contact our support team for assistance with API integration or enterprise API requirements.
{% endhint %}
# Overview
Build integrations on the Taskade REST API: manage workspaces, projects, tasks, AI agents, and media via authenticated endpoints with Node, Python, and cURL.
**Connect. Build. Automate.** The Taskade API enables you to programmatically access and manage your Taskade workspace, projects, tasks, agents, and more.
{% hint style="success" %}
**Developer API** - Build integrations that connect Taskade with your existing tools and workflows. The Taskade API provides RESTful endpoints for managing your workspace data.
{% endhint %}
## API Overview
### What You Can Build
The Taskade API enables you to create integrations that:
**π Workspace & Project Management:**
* Access and manage workspaces and folders
* Create, copy, and manage projects
* Share projects via shareable links
**β
Task Management:**
* Create, update, and complete tasks
* Assign team members to tasks
* Set due dates and manage task notes
* Work with custom fields
**π€ AI Agent Integration:**
* Manage AI agents programmatically
* Add knowledge sources to agents
* Access agent conversations
* Configure public agent access
**π Media Management:**
* Access and manage uploaded media files
* Attach media to agent knowledge bases
### API Base URL
```
https://www.taskade.com/api/v1
```
## Authentication
All API requests require authentication using either OAuth 2.0 or Personal Access Tokens.
{% hint style="warning" %}
Keep your API keys secure and never expose them in client-side code or public repositories.
{% endhint %}
### Getting Your Personal Access Token
1. Go to **Settings** β **Developer** β **Personal Access Tokens**
2. Click **Generate New Token**
3. Copy the token and store it securely
4. Use the token in the `Authorization` header
### Authentication Headers
```bash
curl -X GET "https://www.taskade.com/api/v1/workspaces" \
-H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
-H "Content-Type: application/json"
```
## Core API Resources
### Workspaces
Workspaces are the top-level containers that organize your projects and folders.
**Available Endpoints:**
* `GET /workspaces` - Get all workspaces for the authenticated user
* `GET /workspaces/{workspaceId}/folders` - Get all folders in a workspace
* `POST /workspaces/{workspaceId}/projects` - Create a project in a workspace
### Folders
Folders (also called Subspaces) organize projects, agents, and media within a workspace.
**Available Endpoints:**
* `GET /folders/{folderId}/projects` - Get all projects in a folder
* `GET /folders/{folderId}/agents` - Get all agents in a folder
* `POST /folders/{folderId}/agents` - Create an agent in a folder
* `POST /folders/{folderId}/agent-generate` - Generate an agent using AI
* `GET /folders/{folderId}/medias` - Get all media files in a folder
* `GET /folders/{folderId}/project-templates` - Get project templates in a folder
### Projects
Projects contain tasks and represent your work items, documents, or structured data.
**Available Endpoints:**
* `GET /projects/{projectId}` - Get a specific project
* `POST /projects` - Create a new project
* `POST /projects/{projectId}/complete` - Mark a project as completed
* `POST /projects/{projectId}/restore` - Restore a completed project
* `POST /projects/{projectId}/copy` - Copy a project to a folder
* `POST /projects/from-template` - Create a project from a template
* `GET /projects/{projectId}/members` - Get project members
* `GET /projects/{projectId}/fields` - Get project custom fields
* `GET /projects/{projectId}/shareLink` - Get the share link for a project
* `PUT /projects/{projectId}/shareLink` - Enable/update share link
* `GET /projects/{projectId}/blocks` - Get all blocks in a project
* `GET /projects/{projectId}/tasks` - Get all tasks in a project
### Tasks
Tasks are the fundamental work units within projects.
**Available Endpoints:**
* `GET /projects/{projectId}/tasks/{taskId}` - Get a specific task
* `PUT /projects/{projectId}/tasks/{taskId}` - Update a task
* `DELETE /projects/{projectId}/tasks/{taskId}` - Delete a task
* `POST /projects/{projectId}/tasks/` - Create tasks in a project
* `POST /projects/{projectId}/tasks/{taskId}/complete` - Mark task as complete
* `POST /projects/{projectId}/tasks/{taskId}/uncomplete` - Mark task as incomplete
* `PUT /projects/{projectId}/tasks/{taskId}/move` - Move a task within the project
**Task Assignees:**
* `GET /projects/{projectId}/tasks/{taskId}/assignees` - Get task assignees
* `PUT /projects/{projectId}/tasks/{taskId}/assignees` - Update task assignees
* `DELETE /projects/{projectId}/tasks/{taskId}/assignees/{assigneeHandle}` - Remove an assignee
**Task Dates:**
* `GET /projects/{projectId}/tasks/{taskId}/date` - Get task due date
* `PUT /projects/{projectId}/tasks/{taskId}/date` - Set/update task due date
* `DELETE /projects/{projectId}/tasks/{taskId}/date` - Remove task due date
**Task Notes:**
* `GET /projects/{projectId}/tasks/{taskId}/note` - Get task note
* `PUT /projects/{projectId}/tasks/{taskId}/note` - Update task note
* `DELETE /projects/{projectId}/tasks/{taskId}/note` - Delete task note
**Task Custom Fields:**
* `GET /projects/{projectId}/tasks/{taskId}/fields` - Get all field values for a task
* `GET /projects/{projectId}/tasks/{taskId}/fields/{fieldId}` - Get a specific field value
* `PUT /projects/{projectId}/tasks/{taskId}/fields/{fieldId}` - Update a field value
* `DELETE /projects/{projectId}/tasks/{taskId}/fields/{fieldId}` - Delete a field value
### AI Agents
AI Agents power intelligent interactions and automations.
**Available Endpoints:**
* `GET /agents/{agentId}` - Get an agent
* `PATCH /agents/{agentId}` - Update an agent
* `DELETE /agents/{agentId}` - Delete an agent
* `PUT /agents/{agentId}/publicAccess` - Enable public access for an agent
**Public Agent Configuration:**
* `GET /agents/{agentId}/public-agent` - Get public agent settings
* `PATCH /agents/{agentId}/public-agent` - Update public agent settings
* `GET /public-agents/{publicAgentId}` - Get a public agent by its public ID
**Agent Knowledge:**
* `POST /agents/{agentId}/knowledge/project` - Add a project to agent knowledge
* `POST /agents/{agentId}/knowledge/media` - Add media to agent knowledge
* `DELETE /agents/{agentId}/knowledge/project/{projectId}` - Remove project from knowledge
* `DELETE /agents/{agentId}/knowledge/media/{mediaId}` - Remove media from knowledge
**Agent Conversations:**
* `GET /agents/{agentId}/convos/` - Get all agent conversations
* `GET /agents/{agentId}/convos/{convoId}` - Get a specific conversation
### Media
Manage uploaded files and media.
**Available Endpoints:**
* `GET /medias/{mediaId}` - Get media details
* `DELETE /medias/{mediaId}` - Delete a media file
### User Projects
Access the authenticated user's projects.
**Available Endpoints:**
* `GET /me/projects` - Get all projects for the current user
## Error Handling
### HTTP Status Codes
* `200 OK` - Request successful
* `400 Bad Request` - Invalid request parameters
* `401 Unauthorized` - Authentication required
* `403 Forbidden` - Insufficient permissions
* `404 Not Found` - Resource not found
* `4XX` - Client error (see response body for details)
### Error Response Format
```json
{
"ok": false,
"message": "Error description",
"code": "ERROR_CODE",
"statusMessage": "HTTP status message"
}
```
## Code Examples
### JavaScript/Node.js
```javascript
const API_BASE = 'https://www.taskade.com/api/v1';
const TOKEN = 'your_access_token';
// Get all workspaces
const getWorkspaces = async () => {
const response = await fetch(`${API_BASE}/workspaces`, {
headers: {
'Authorization': `Bearer ${TOKEN}`,
'Content-Type': 'application/json'
}
});
return response.json();
};
// Get project tasks
const getProjectTasks = async (projectId) => {
const response = await fetch(`${API_BASE}/projects/${projectId}/tasks`, {
headers: {
'Authorization': `Bearer ${TOKEN}`,
'Content-Type': 'application/json'
}
});
return response.json();
};
// Create a task
const createTask = async (projectId, content) => {
const response = await fetch(`${API_BASE}/projects/${projectId}/tasks/`, {
method: 'POST',
headers: {
'Authorization': `Bearer ${TOKEN}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
tasks: [{
contentType: 'text/markdown',
content: content,
placement: 'beforeend'
}]
})
});
return response.json();
};
```
### Python
```python
import requests
API_BASE = 'https://www.taskade.com/api/v1'
TOKEN = 'your_access_token'
headers = {
'Authorization': f'Bearer {TOKEN}',
'Content-Type': 'application/json'
}
# Get all workspaces
def get_workspaces():
response = requests.get(f'{API_BASE}/workspaces', headers=headers)
return response.json()
# Get project tasks
def get_project_tasks(project_id):
response = requests.get(f'{API_BASE}/projects/{project_id}/tasks', headers=headers)
return response.json()
# Complete a task
def complete_task(project_id, task_id):
response = requests.post(
f'{API_BASE}/projects/{project_id}/tasks/{task_id}/complete',
headers=headers
)
return response.json()
```
### cURL Examples
```bash
# Get all workspaces
curl -X GET "https://www.taskade.com/api/v1/workspaces" \
-H "Authorization: Bearer YOUR_TOKEN"
# Get projects in a folder
curl -X GET "https://www.taskade.com/api/v1/folders/FOLDER_ID/projects" \
-H "Authorization: Bearer YOUR_TOKEN"
# Get an agent
curl -X GET "https://www.taskade.com/api/v1/agents/AGENT_ID" \
-H "Authorization: Bearer YOUR_TOKEN"
```
## Best Practices
### Security
* Store API tokens securely (environment variables, secret management)
* Use HTTPS for all API calls
* Implement proper error handling
* Never expose tokens in client-side code
### Performance
* Use pagination for large result sets
* Cache responses when appropriate
* Implement rate limit handling with exponential backoff
### Data Management
* Validate data before sending to API
* Handle partial failures gracefully
* Use cursor-based pagination for tasks and blocks
## Quick Start Guide
{% stepper %}
{% step %}
#### Get Your Access Token
Navigate to Settings β Developer β Personal Access Tokens and generate a new token.
{% endstep %}
{% step %}
#### Make Your First API Call
Use cURL or your preferred language to test the API connection by fetching your workspaces.
{% endstep %}
{% step %}
#### Explore the Endpoints
Review the available endpoints in each resource section.
{% endstep %}
{% step %}
#### Build Your Integration
Start with basic operations, then add complexity as needed.
{% endstep %}
{% endstepper %}
## Support and Resources
### Documentation
* [**Personal Access Tokens**](/developers/authentication/personal-tokens) - Learn about authentication
* [**OAuth Authentication**](/developers/authentication) - OAuth 2.0 setup
### Support
* **Email:** <support@taskade.com>
* **Help Center:** [taskade.com/learn](https://www.taskade.com/learn)
***
> **π‘ Pro Tip**: Start with the `/workspaces` endpoint to discover your workspace structure, then navigate through folders and projects to access the data you need.
# Workspaces
Workspaces β Taskade REST API v1 reference: GET /workspaces. Parameters, authentication, and response schema.
## Summary of Endpoints
### Workspaces
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/workspaces" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Folders
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/workspaces/{workspaceId}/folders" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Projects
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/workspaces/{workspaceId}/projects" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Get Workspaces
Get Workspaces β Taskade REST API v1 reference: GET /workspaces. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/workspaces" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Create a Project
Create a Project in a Workspace β Taskade REST API v1 reference: POST /workspaces/{workspaceId}/projects. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/workspaces/{workspaceId}/projects" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Get Folders
Get Folders β Taskade REST API v1 reference: GET /workspaces/{workspaceId}/folders. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/workspaces/{workspaceId}/folders" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Projects
Projects β Taskade REST API v1 reference: GET /projects/{projectId}. Parameters, authentication, and response schema.
The **Knowledge Layer** is the foundation of every intelligent app you build in Taskade. This is the structured memory that your AI Agents use to understand context, make decisions, and provide insightful responses. This layer is powered by **Taskade Projects**.
A Project is a flexible, powerful resource that can be used as:
* A structured database for a CRM or a directory.
* A content repository for a knowledge base or documentation site.
* A task list for a project management system.
* A queue for processing data in an automation workflow.
**Task Add-ons** β Every project node can be enriched with optional add-ons including **attachments**, **assignments**, **timers / due-dates**, **reactions & comments**, **custom fields**, and **AI pills** for context-aware suggestions. These add-ons travel with the node and are fully accessible via the Tasks API.
These endpoints allow you to create, read, update, and delete the Projects that form the Knowledge Layer of your applications.
### Learn More
* [**Agent Knowledge & Memory βΊ**](https://www.taskade.com/learn/agents/knowledge)
## Summary of Endpoints
### Get Project
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Complete Project
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/complete" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Restore Project
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/restore" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Copy Project
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/copy" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Create Project
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Create From Template
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/from-template" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Get Project Members
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/members" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Get Project Fields
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/fields" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Get Share Link
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/shareLink" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Update Share Link
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/shareLink" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Get Project Blocks
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/blocks" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Get Project Tasks
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Get Project
Get Project β Taskade REST API v1 reference: GET /projects/{projectId}. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Create Project
Create Project β Taskade REST API v1 reference: POST /projects. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Complete Project
Complete Project β Taskade REST API v1 reference: POST /projects/{projectId}/complete. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/complete" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Restore Project
Restore Project β Taskade REST API v1 reference: POST /projects/{projectId}/restore. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/restore" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Copy Project
Copy Project β Taskade REST API v1 reference: POST /projects/{projectId}/copy. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/copy" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Create From Template
Create From Template β Taskade REST API v1 reference: POST /projects/from-template. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/from-template" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Get Project Members
Get Project Members β Taskade REST API v1 reference: GET /projects/{projectId}/members. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/members" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Get Project Fields
Get Project Fields β Taskade REST API v1 reference: GET /projects/{projectId}/fields. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/fields" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Get Project Tasks
Get Project Tasks β Taskade REST API v1 reference: GET /projects/{projectId}/tasks. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Get Project Block
Get Project Block β Taskade REST API v1 reference: GET /projects/{projectId}/blocks. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/blocks" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Get Share Link
Get Share Link β Taskade REST API v1 reference: GET /projects/{projectId}/shareLink. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/shareLink" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Update Share Link
Update Share Link β Taskade REST API v1 reference: PUT /projects/{projectId}/shareLink. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/shareLink" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Tasks
Tasks β Taskade REST API v1 reference: GET /projects/{projectId}/tasks/{taskId}. Parameters, authentication, and response schema.
## Summary of Endpoints
### Get Task
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Delete Task
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}" method="delete" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Update Task
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Complete Task
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/complete" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Uncomplete Task
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/uncomplete" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Create Task
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Move Task
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/move" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Get Task Assignees
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/assignees" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Update Task Assignees
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/assignees" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Delete Task Assignee
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/assignees/{assigneeHandle}" method="delete" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Get Task Date
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/date" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Delete Task Date
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/date" method="delete" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Update Task Date
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/date" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Get Task Note
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/note" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Update Task Note
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/note" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Delete Task Note
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/note" method="delete" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### List Task Fields
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/fields" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Get Task Field
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/fields/{fieldId}" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Delete Task Field
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/fields/{fieldId}" method="delete" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
### Update Task Field
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/fields/{fieldId}" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Create Task
Create Task β Taskade REST API v1 reference: POST /projects/{projectId}/tasks/. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Get Task
Get Task β Taskade REST API v1 reference: GET /projects/{projectId}/tasks/{taskId}. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Update Task
Update Task β Taskade REST API v1 reference: PUT /projects/{projectId}/tasks/{taskId}. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Move Task
Move Task β Taskade REST API v1 reference: PUT /projects/{projectId}/tasks/{taskId}/move. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/move" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Complete Task
Complete Task β Taskade REST API v1 reference: POST /projects/{projectId}/tasks/{taskId}/complete. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/complete" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Uncomplete Task
Uncomplete Task β Taskade REST API v1 reference: POST /projects/{projectId}/tasks/{taskId}/uncomplete. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/uncomplete" method="post" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Delete Task
Delete Task β Taskade REST API v1 reference: DELETE /projects/{projectId}/tasks/{taskId}. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}" method="delete" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Task Assignees
Task Assignees β Taskade REST API v1 reference: GET /projects/{projectId}/tasks/{taskId}/assignees. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/assignees" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Update Task Assignees
Update Task Assignees β Taskade REST API v1 reference: PUT /projects/{projectId}/tasks/{taskId}/assignees. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/assignees" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Delete Task Assignees
Delete Task Assignees β Taskade REST API v1 reference: DELETE /projects/{projectId}/tasks/{taskId}/assignees/{assigneeHandle}. Parameters,β¦
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/assignees/{assigneeHandle}" method="delete" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Get Task Date
Get Task Date β Taskade REST API v1 reference: GET /projects/{projectId}/tasks/{taskId}/date. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/date" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Update Task Date
Update Task Date β Taskade REST API v1 reference: PUT /projects/{projectId}/tasks/{taskId}/date. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/date" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Delete Task Date
Delete Task Date β Taskade REST API v1 reference: DELETE /projects/{projectId}/tasks/{taskId}/date. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/date" method="delete" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Get Task Note
Get Task Note β Taskade REST API v1 reference: GET /projects/{projectId}/tasks/{taskId}/note. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/note" method="get" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
# Update Task Note
Update Task Note β Taskade REST API v1 reference: PUT /projects/{projectId}/tasks/{taskId}/note. Parameters, authentication, and response schema.
{% openapi src="/files/BofPKQdStkZSorv2iHCa" path="/projects/{projectId}/tasks/{taskId}/note" method="put" expanded="true" %}
[api-0.1.0.json](https://884954080-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEOkDZjClZ0y8qSYnc7hO%2Fuploads%2Fgit-blob-5873acadd91fa22796bcbdfd34590bd596f4ecd7%2Fapi-0.1.0.json?alt=media)
{% endopenapi %}
---
[Next Page](/llms-full.txt/1)