One command. A whole engineering crew.

Flightdeck is the orchestration layer for AI coding agents. It coordinates crews of agents working in parallel on your codebase, each with a specialized role, its own context window, and structured communication channels.

npm install -g @flightdeck-ai/flightdeck
flightdeck

Give it a task, and a Project Lead agent breaks it down into a dependency graph, assembles the right specialists (developers, architects, reviewers, and more), and coordinates their parallel execution while you stay in the loop through a real-time web dashboard. Works with GitHub Copilot, Claude Code, Gemini CLI, Codex, Cursor, OpenCode, Kimi, and Qwen Code — mix and match providers in the same crew.

Lead Dashboard — your home screen for tracking projects, agents, and progress

Timeline — zoom, scroll, and replay agent activity with session scrubber

More screenshots

Command Palette	Canvas View

Mission Control	Analytics

Timeline	Overview

Batch Approval	New Project

• Node.js 20+ — Download
• At least one AI coding CLI — GitHub Copilot, Claude Code, Gemini CLI, Codex, Cursor, OpenCode, Kimi, or Qwen Code

npm install -g @flightdeck-ai/flightdeck
flightdeck

The dashboard opens at http://localhost:3001. That's it.

1. Create a project — Click Create Project, describe what you want built, and point it at your repo
2. Watch the lead plan — The Project Lead agent analyzes your task, breaks it into a task DAG, and assembles a crew
3. Agents get to work — Developers, reviewers, architects spin up in parallel — each in their own CLI session with your configured provider
4. Stay in the loop — Message any agent directly, approve decisions, and watch progress in real time

Example: "Refactor the auth module to use JWT tokens, add tests, and update the docs" → The lead creates a developer (implementation), a code reviewer (quality), and a tech writer (docs), sets up dependencies so the reviewer waits for the developer, and coordinates the whole flow.

First time? Flightdeck defaults to GitHub Copilot. Change the provider in Settings or in flightdeck.config.yaml.

CLI options: --port=4000 · --host=0.0.0.0 · --no-browser · -v / --version · -h / --help

npm install
npm run build
npm start

npm run dev

• Project Lead — Breaks down tasks, assembles a crew, creates a task DAG, delegates work, and synthesizes results
• 14 Specialized Roles — Developer, Architect, Code Reviewer, Critical Reviewer, Readability Reviewer, Tech Writer, QA Tester, and more (see Agent Roles)
• Task DAG — Declarative task scheduling with dependencies; agents work in parallel when possible, sequentially when required
• Human-in-the-Loop — Message any agent directly; queue, reorder, or remove messages before delivery
• 8 AI Providers — GitHub Copilot, Claude Code, Gemini CLI, Codex, Cursor, OpenCode, Kimi, Qwen Code — mix and match in the same crew

• File Locking — Pessimistic locks with TTL and glob support prevent concurrent edits
• Scoped Commits — git add only on files the agent has locked. Prevents git add -A from leaking other agents' work
• Trust Dial — 3-level oversight (Supervised / Balanced / Autonomous) controls how much approval you give. Per-project overrides supported
• Governance Pipeline (future feature) — Infrastructure for ordered command hooks (security → permission → validation → rate-limit → policy → approval) exists but is currently disabled
• Security — Prompt injection sanitization (4-layer), secret redaction, CORS lockdown, rate limiting, path traversal validation

• Lead Dashboard — Chat with the Project Lead, approve decisions, and monitor crew status — all in one screen
• Timeline — Swim-lane visualization with zoom, scroll, keyboard navigation, and session replay scrubber
• Task Views — DAG graph, Kanban board, and Gantt chart — three ways to visualize your task pipeline
• Token Economics — Per-agent and per-task token usage from provider data
• AttentionBar — Persistent status bar with escalation states (green/yellow/red) — know at a glance if anything needs you

• Direct Messaging — Agents send structured messages to each other by ID
• Group Chat — Create groups by member ID or role; auto-created when 3+ agents work on the same feature
• Broadcasts — Send a message to every active agent at once
• Telegram Integration — Receive notifications via Telegram bot with batched delivery and challenge-response auth

• Knowledge Pipeline — Automatic knowledge injection on agent spawn, extraction on agent exit
• 4-Category Knowledge Base — Core (project rules), Procedural (patterns), Semantic (facts), Episodic (session context)
• Skills System — .github/skills/ files are hot-reloaded into agent prompts
• CollectiveMemory — Cross-session knowledge that compounds over time
• Session Resume — Resume from a previous session with full context recovery

Flightdeck uses a three-tier architecture with clear separation of concerns:

┌──────────────────────────────────────────────────────────────────┐
│                      Web Client (Vite/React)                     │
│  Dashboard · Project Views · Session Management · Real-time UI   │
│  React 19 · TailwindCSS 4 · Zustand · WebSocket client          │
└───────────────────────┬──────────────────────────────────────────┘
                        │ REST API + WebSocket (/ws)
┌───────────────────────▼──────────────────────────────────────────┐
│                  Orchestration Server (Express 5)                 │
│  Session mgmt · Project mgmt · GovernancePipeline · Task DAG     │
│  Knowledge · Decisions · File locks · Chat groups · Integrations │
│  SQLite/Drizzle · Zod validation · Pino logging                  │
└───────────────────────┬──────────────────────────────────────────┘
                        │ stdio + PID file (detached child process)
┌───────────────────────▼──────────────────────────────────────────┐
│                    Agent Server (Daemon)                          │
│  Spawns & manages CLI agent processes via ACP protocol           │
│  Copilot · Claude · Gemini · Codex · Cursor · OpenCode · Kimi · Qwen  │
│  Per-agent lifecycle · Auto-restart · Heartbeat monitoring        │
└──────────────────────────────────────────────────────────────────┘

1. Client ↔ Orchestration Server — The React frontend communicates with the Express server via REST endpoints (28 route modules covering agents, projects, sessions, tasks, decisions, knowledge, etc.) and a persistent WebSocket connection on /ws for real-time updates. WebSocket events are batched and throttled (agent text flushed every 100ms).

2. Orchestration Server ↔ Agent Server — The orchestration server forks the agent server as a detached child process, communicating via stdio and monitoring health with heartbeat pings. The agent server manages individual CLI agent processes (Copilot, Claude, Gemini, Codex, Cursor, OpenCode, Kimi, Qwen Code) through the ACP (Agent Client Protocol) — each agent runs as a separate subprocess with its own context window and role.

3. Command flow — Agents emit structured commands (wrapped in doubled Unicode brackets) in their output stream. The CommandDispatcher parses these and routes them to 9 domain-specific command modules (AgentCommands, TaskCommands, CommCommands, etc.). The GovernancePipeline intercepts commands through ordered hooks: security → permission → validation → rate-limit → policy → approval, with post-hooks for audit and metrics.

See the Architecture Decisions page for the rationale behind key design choices.

Flightdeck uses layered configuration: hardcoded defaults ← YAML config ← environment variables ← runtime API.

Config file (flightdeck.config.yaml):

server:
  maxConcurrentAgents: 50        # 1–1000

heartbeat:
  idleThresholdMs: 60000         # Idle agent detection threshold
  crewUpdateIntervalMs: 180000   # Crew status push interval

models:
  defaults:                      # Default model per role
    lead: [claude-opus-4.6]
    developer: [claude-opus-4.6]
    architect: [claude-opus-4.6]
    code-reviewer: [gemini-3-pro-preview]
    # ... (14 roles total)

provider:
  id: copilot                    # Active provider: copilot | claude | gemini | codex | cursor | opencode | kimi | qwen-code

budget:
  limit: null                    # null = unlimited; set a dollar amount to cap spend
  thresholds:
    warning: 0.7
    critical: 0.9
    pause: 1.0

See flightdeck.config.example.yaml for the full reference.

Key environment variables:

Each agent is assigned a role with a specialized system prompt. The lead creates agents and assigns them tasks.

Custom roles can be created via the Settings UI with your own system prompts, colors, and icons.

AI-Aware Estimation: Traditional human timelines don't apply. A crew of AI agents can compress weeks of work into hours. Plan in sessions (30 min – 2 hours), not sprints. See the agent-collaboration-patterns skill for calibration data.

Agents communicate via structured commands wrapped in doubled Unicode brackets (⟦⟦ COMMAND {...} ⟧⟧, U+27E6/U+27E7) detected in their output stream. Commands are parsed by the CommandDispatcher and routed to the appropriate subsystem.

• Frontend: React 19, Vite, TypeScript, Tailwind CSS 4, Zustand, ReactFlow, visx (timeline), Lucide
• Backend: Node.js, Express 5, ws (WebSocket)
• Database: SQLite (WAL mode, Drizzle ORM) with tuned pragmas (busy_timeout, foreign_keys, synchronous=NORMAL)
• Security: Auto-generated auth tokens, CORS lockdown, rate limiting, path traversal validation
• Validation: Zod schemas on all API routes
• Agent Protocol: ACP (Agent Communication Protocol) with streaming command detection
• Events: Typed event bus (TypedEmitter) with strongly-typed events
• Testing: Vitest with v8 coverage, Codecov integration
• CI: GitHub Actions on main and team-work-* branches — typecheck, unit tests, coverage upload

Flightdeck has extensive documentation across guides, references, and design documents:

Flightdeck is purely AI-created with human supervision. Every line of code, test, and documentation was written by AI agents coordinated through Flightdeck itself — a real-world demonstration of multi-agent software development.

We welcome contributions! Flightdeck is MIT licensed and built in the open.

• Bug reports — Open an issue
• Feature requests — Open a discussion
• Pull requests — Fork, branch, and submit a PR. Each feature gets its own branch.

# Local development
npm install
npm run dev    # Starts server + web with hot reload

Flightdeck is built on many excellent open-source projects. See docs/CREDITS.md for full attribution, including the research projects, agent SDKs, core libraries, and design references that made this possible.

MIT — Copyright (c) 2026 Justin Chuby