Open-source AI-powered task management with Kanban, integrations, and team collaboration.

TaskClaw is a self-hostable task management platform that combines a visual Kanban board with AI chat, knowledge management, and bidirectional sync with tools like Notion and ClickUp. Think of it as your AI-powered command center for tasks.

Key Features:

• Kanban Board — Drag-and-drop task management with status columns
• AI Chat — Talk to an AI assistant about your tasks (bring your own API key)
• Knowledge Base — Feed context to the AI for smarter assistance
• Integrations — Bidirectional sync with Notion, ClickUp, and more (community-extensible)
• MCP Server — Model Context Protocol server for AI agents (Claude Code, Cursor, Windsurf)
• API Keys & Webhooks — Programmatic access and real-time event notifications
• OpenAPI Spec — Full REST API documentation at /api/docs
• Team Collaboration — Share projects and tasks with your team
• Skills & Categories — Organize tasks by context and teach the AI custom skills
• Pomodoro Timer — Built-in focus timer with task association
• Dark Mode — Premium, distraction-free interface

Try TaskClaw instantly with npx (requires Node.js + Docker). This runs a local instance on your own machine at http://localhost:3000 — nothing is deployed to a remote server:

npx taskclaw

Or deploy with Docker directly:

curl -fsSL https://raw.githubusercontent.com/taskclaw/taskclaw/main/scripts/install.sh | sh

Open http://localhost:3000 and log in:

That's it! Everything starts automatically: database, auth, API, and frontend — all behind a single port.

npx taskclaw stop       # Stop TaskClaw
npx taskclaw logs       # View logs
npx taskclaw upgrade    # Pull latest & restart
npx taskclaw reset      # Stop + delete all data

The quickstart above runs on your local machine. To run TaskClaw on a remote server that others can reach, point one command at any fresh Ubuntu/Debian host:

npx taskclaw remote --host <your-server-ip>

This single command provisions Docker on the server, generates unique secrets, brings up the full stack, and saves a credentials file you can keep. To serve over HTTPS at your own domain (DNS A-record + TLS-terminating proxy required), add:

npx taskclaw remote --host <your-server-ip> --domain <example.com>

See docs/self-hosting.md for the full server guide.

git clone https://github.com/taskclaw/taskclaw.git && cd taskclaw
docker compose -f docker-compose.quickstart.yml up -d

If you're an AI agent like Claude Code, Cursor, or Windsurf, you can access TaskClaw programmatically via the MCP server:

1. Build the MCP server:

   cd backend && npm run build:mcp

2. Configure in your IDE (example for Claude Code):

   {
     "mcpServers": {
       "taskclaw": {
         "command": "node",
         "args": ["/path/to/taskclaw/backend/dist/mcp-entry.js"],
         "env": {
           "TASKCLAW_API_URL": "http://localhost:3003",
           "TASKCLAW_API_KEY": "tc_live_xxxxxxxxxxxxx"
         }
       }
     }
   }

3. Use TaskClaw tools directly in your AI conversations:

   @mcp taskclaw list_boards account_id=...
   @mcp taskclaw create_task account_id=... title="Fix bug" board_id=...
   

See MCP Server Documentation for full setup and tool reference.

Customize the stack via env files:

cp .env.example .env
cp backend/.env.example backend/.env
cp frontend/.env.example frontend/.env
# Edit .env files (DATABASE_URL, JWT_SECRET, ENCRYPTION_KEY, S3/MinIO, etc.)
docker compose up -d

This brings up the full plain-PostgreSQL stack: Postgres (pgvector), MinIO (S3-compatible storage), Redis, the NestJS backend, and the Next.js frontend. The backend applies Drizzle migrations + seeds on boot and creates MinIO buckets automatically.

Self-Hosting on a server (remote host, over HTTP)

Running on a real server (not localhost) needs a few extra steps the quickstart doesn't cover:

1. Set strong secrets and your public URL. The quickstart compose reads these from a .env file next to the compose file (or the shell environment). CORS and the Server Actions allowed-origin both derive from SITE_URL automatically:

   POSTGRES_PASSWORD=<strong-random-password>
   JWT_SECRET=<strong-random-secret>          # openssl rand -hex 32
   ENCRYPTION_KEY=<strong-random-hex-string>  # openssl rand -hex 32
   SITE_URL=http://<your-server-ip>:3000      # or EXTERNAL_PORT=80 + SITE_URL=http://<your-server-ip>
   MINIO_ROOT_USER=<user>
   MINIO_ROOT_PASSWORD=<strong-random-password>
   # MinIO / S3-compatible storage — point S3_PUBLIC_URL at a browser-reachable URL:
   S3_PUBLIC_URL=http://<your-server-ip>:9000

2. Over plain HTTP, COOKIE_SECURE must be false (the quickstart compose default). Otherwise the auth session cookie is marked Secure, browsers silently drop it, and login never reaches the dashboard. (For production, serve HTTPS instead and set it to true.)

   The frontend serves a single-origin /api/[...path] proxy that forwards to the backend over the Docker network (INTERNAL_API_URL=http://backend:3003) and injects the Bearer token from the httpOnly auth_token cookie — so the published frontend image works on any host without rebuilding NEXT_PUBLIC_* URLs.

3. First login may need activation. New signups start as pending — set the user's status='active' in the DB (or approve via admin) before they can sign in. Live board updates flow over Postgres LISTEN/NOTIFY → NestJS SSE (/events/stream) and work out of the box.

See docs/self-hosting.md for the full self-hosting guide, and docs/development.md for the full development setup guide.

TASKCLAW_VERSION=v2.0.0 docker compose pull && docker compose up -d

• OpenAPI Spec: Visit http://localhost:3003/api/docs when running locally
• Interactive Docs: Test all endpoints directly from the Swagger UI
• JSON Spec: Download from http://localhost:3003/api/docs-json

TaskClaw uses a pluggable adapter system for integrations. Adding a new integration is one of the best ways to contribute.

See Adding an Integration to get started.

Don't want to self-host? TaskClaw Cloud provides a fully managed version with additional features:

• Managed infrastructure with automatic updates
• Billing and subscription management
• Advanced AI usage analytics
• Priority support

• Frontend: Next.js 15, React 18, Tailwind CSS, shadcn/ui, Zustand, TanStack Query
• Backend: NestJS 11, TypeScript
• Database: PostgreSQL (pgvector) via Drizzle ORM
• Auth: Local NestJS JWT auth (bcrypt + refresh tokens)
• Storage: MinIO (S3-compatible)
• Realtime: Postgres LISTEN/NOTIFY → NestJS SSE
• AI: OpenRouter API (bring your own key)
• Queue: BullMQ + Redis
• Drag & Drop: @dnd-kit

TaskClaw ships with Claude Code skills that let you create boards, agents, skills, and knowledge bases through guided AI conversations. Just invoke a slash command and Claude walks you through a wizard, then generates a JSON manifest you can import.

1. Install Claude Code and open the TaskClaw project
2. Run a skill command (e.g. /board-architect)
3. Claude guides you through a wizard-like Q&A
4. It generates a JSON manifest in the TaskClaw bundle format
5. Go to Import in the TaskClaw sidebar (/dashboard/import) and drop your .json file
6. Everything is provisioned automatically (boards, agents, skills, knowledge docs)

Skills live in .claude/skills/<name>/ with this structure:

.claude/skills/my-skill/
├── SKILL.md              # Required — main definition (YAML frontmatter + markdown)
├── references/           # Optional — schemas, guides
└── assets/               # Optional — examples, templates

See .claude/skills/README.md for the full authoring guide.

We welcome contributions! See CONTRIBUTING.md for guidelines.

The most impactful contributions are new integrations — check out the integration guide to add support for your favorite tool.

• GitHub Issues — Bug reports and feature requests
• GitHub Discussions — Questions and ideas
• Vision & Roadmap — Where TaskClaw is headed

TaskClaw is licensed under the Sustainable Use License — free for personal and internal business use. Enterprise license required for providing hosted services. Files in backend/src/ee/ are governed by a separate Enterprise License.

Created by DevOtts.