A self-hosted task manager that runs your work through AI agents. You add tasks, set priorities, and Autopilot handles execution: it spawns Claude Code or Codex CLI sessions, streams output live, and routes decisions back to you.
Runs entirely on your machine. Data in ~/.cmc/. No cloud.
Workspace
├── Objectives (long-term outcomes)
├── Projects (group related work)
│ └── Initiatives (active execution units, linked to an Objective)
│ └── Tasks (work items; agents run these)
Tasks are things agents do: research, write code, analyze, plan. They execute as Claude Code or Codex CLI sessions, stream output live, and mark themselves done.
AI agent tools usually mean handing your tasks, credentials, and decisions to a cloud service. Task Control takes the opposite approach:
- Data in
~/.cmc/: persists across app updates, never synced anywhere - No database: plain JSON files you can read, edit, or back up directly
- No vendor lock-in: agents run via Claude Code or Codex CLI, both locally installed
- Full audit trail: every agent action logged in activity-log.json
Agents read and write the same JSON files the UI uses. There's no API translation layer between "what the agent sees" and "what you see."
The daemon (pnpm daemon:start) is the engine. It runs as a detached background process, independent of the web server, and handles autonomous execution:
- Watches for tasks via file system events; picks up new work immediately as tasks.json changes
- Spawns agent sessions up to your concurrency limit
- Persists across server restarts:
autoStart: truein daemon-config.json auto-relaunches on Next.js boot - Crash recovery: on restart, orphaned in-progress tasks are reset; interrupted Claude sessions resume via
--resume <sessionId>using the persisted conversation ID - Human-input pause: when an agent needs a decision, it sets
awaiting-decisionstatus; Autopilot resumes automatically once you answer - Permission escalation: if an agent tries to use a tool outside its allowed list, it auto-generates a decision item rather than failing silently
- Inbox loop: Autopilot posts to your inbox when it picks up, completes, or fails a task — you stay informed without watching dashboards
- Exponential retry: failed tasks retry with backoff, up to a configurable limit
- Scheduled commands: runs
/daily-plan,/standup,/weekly-reviewon cron schedules
- Eisenhower Matrix: Prioritize by importance x urgency; drag-and-drop between Do, Schedule, Delegate, Eliminate
- Kanban Board: Not Started → In Progress → Done (+ Awaiting Decision for paused agent tasks)
- Workspaces: Isolated data contexts; switch workspaces from the sidebar header
- Objectives + Projects + Initiatives: Long-term objectives broken into initiatives via projects; each initiative owns its Tasks and Actions
- Quick Capture: Capture ideas instantly, triage into tasks later
- Autonomous Daemon: 24/7 background process with concurrency control, retry queue, and live dashboard at
/autopilot - One-Click Execution: Press play on any task card to manually spawn an agent session
- Real-Time Streaming: Watch agent output live: tool calls, responses, progress as it happens
- Multi-CLI Backend: Claude Code or Codex CLI, configurable per agent
- @-Mention in Comments: Tag any agent in a task or action comment; they read the context and respond inline
- Continuous Missions: Run an entire project; tasks auto-dispatch as dependencies resolve
- Loop Detection: Agents that keep failing the same task are escalated after 3 attempts rather than burning tokens indefinitely — safe to leave running unattended
- Auto-Start on Boot: Daemon relaunches automatically when the Next.js server starts
- Session Resume: Claude session IDs captured from stream output; crashed sessions resume mid-conversation
- Crash Recovery Sweep: Orphaned in-progress tasks detected on startup and reset for redispatch
- Persistent Retry Queue: Survives daemon restarts; retries resume with correct backoff timing
- Markdown Descriptions: Full markdown rendering in task descriptions; click to edit
- File Attachments: Attach images and files to task descriptions and comments; stored in
~/.cmc/uploads/ - Inline Previews: Images render inline in comments; other files as download links
- Comments: Full comment thread and @-mention support on tasks
- Cost & Token Tracking: Input, output, cache read/write tokens per session, cumulative totals
- Live Session Console: Expandable stream view for active sessions on the Automation page
- SSE Stream API:
GET /api/runs/stream?runId=Xfor programmatic live output access - Activity Logbook: Timestamped event log of all agent and system activity
| Requirement | Why | Install |
|---|---|---|
| Node.js v20+ | Runtime | nodejs.org |
| pnpm v9+ | Package manager | npm install -g pnpm |
| Claude Code (recommended) | Agent execution | npm install -g @anthropic-ai/claude-code |
| Codex CLI (optional) | Alternative agent backend | npm install -g @openai/codex |
The web UI runs standalone for task management. Claude Code or Codex CLI is required to actually execute tasks via agents.
git clone https://github.com/anh-chu/claude-mission-control.git
cd claude-mission-control/mission-control
pnpm install
pnpm devOpen http://localhost:3000. On first run, click "Load Demo Data" to explore with sample tasks, agents, and messages.
Your workspace data is created at ~/.cmc/ on first launch, separate from the repo, so git pull never touches your data.
pnpm daemon:startOr start it from Settings → Autopilot in the UI. Once started, Autopilot will automatically relaunch on server restart until you explicitly stop it.
- Open the Priority Matrix and drag tasks into Do, Schedule, Delegate, or Eliminate
- Click a task to open the detail panel and add a description, subtasks, or attach a file
- Press Launch on a task assigned to an agent and watch it execute live on the Automation page
- Check your Inbox for agent completion reports and questions
Autopilot watches tasks.json for changes
→ Finds tasks: kanban=not-started, assignedTo≠me, unblocked
→ Spawns a Claude Code / Codex CLI session with agent persona + task context
→ Agent executes, streams output live to ~/.cmc/agent-streams/<id>.jsonl
→ Agent marks task done, posts completion report to inbox.json
→ If agent needs human input → sets awaiting-decision, Autopilot pauses
→ You answer the decision → Autopilot resumes the task
Server restarts (or crashes)
→ instrumentation.ts runs on Next.js boot
→ Reads daemon-config.json: if autoStart=true, spawns daemon
→ Daemon reads daemon-session-recovery.json for persisted session IDs
→ For each orphaned in-progress task:
Has session ID → attempts claude --resume <sessionId> to continue mid-task
No session ID → resets to not-started, picked up on next file change
You comment "@researcher check the API docs"
→ Task Control parses the mention, validates agent exists
→ Spawns dedicated agent session with task context + your comment
→ Agent responds with a new comment (streams live)
→ If agent determines rework is needed on a done task, it reopens automatically
All endpoints are designed for minimal token consumption. Agents use these to read and write task data.
# Filtered task queries (much cheaper than fetching everything)
GET /api/tasks?assignedTo=developer&kanban=not-started&fields=id,title,description
# Eisenhower quadrant filter
GET /api/tasks?quadrant=do
# Live agent output stream (Server-Sent Events)
GET /api/runs/stream?runId=run_123
# Comment with @-mention (auto-spawns agent handler)
POST /api/tasks/:id/comment { "content": "@researcher check this", "author": "me" }
# Manual task execution
POST /api/tasks/:id/run
# Project-wide execution (all eligible tasks)
POST /api/projects/:id/runAll write endpoints use Zod validation and async-mutex locking for concurrent multi-agent safety.
| Role | Handles |
|---|---|
| Me | Decisions, approvals, creative direction (human only) |
| Researcher | Market research, competitive analysis, evaluation |
| Developer | Code, bug fixes, testing, deployment |
| Marketer | Copy, growth strategy, content, SEO |
| Business Analyst | Strategy, planning, prioritization, financials |
| Tester | QA testing, bug reporting, performance analysis |
| + Custom | Unlimited custom agents with unique instructions and skills |
Each agent can use Claude Code or Codex CLI as its backend, configurable from the Agents page.
~/.cmc/ All persistent data, never inside the repo
workspaces.json Workspace registry
workspaces/{id}/
tasks.json Tasks (Eisenhower + kanban + agent assignment)
initiatives.json Initiatives (group related tasks)
goals.json Long-term goals
agents.json Agent registry (persona, instructions, backend)
inbox.json Agent <-> human messages
decisions.json Pending decisions awaiting human input
activity-log.json Full event log
daemon-config.json Autopilot config (concurrency, autoStart, schedule)
daemon-session-recovery.json Claude session IDs for crash resume
agent-streams/ Live JSONL output per active agent session
uploads/ File attachments (served at /uploads/[filename])
mission-control/ Next.js 15 app (source only, no data here)
instrumentation.ts Boot hooks: upload cleanup + daemon auto-start
scripts/daemon/
index.ts Daemon start/stop/status + startup crash recovery
dispatcher.ts Task dispatch, retry queue, session resume, inbox notifications
runner.ts CLI runner (Claude Code + Codex, stream-json output)
recovery.ts Orphan detection + session ID persistence
health.ts Session tracking, PID checks, status persistence
scheduler.ts Cron scheduled commands
src/app/ Pages + API routes
src/components/ React components (shadcn/ui)
src/lib/ Data layer, validation, adapters
- Local-first: No database. No cloud. Plain JSON in
~/.cmc/. Yours forever. - Agent-first API: Every endpoint optimized for token-efficient agent reads and writes.
- Daemon-first execution: Autopilot is the default path, not an optional add-on.
- Resilience by default: Crash recovery, session resume, and retry queues built into the daemon.
- Defense in depth: Emergency stop, human-in-the-loop decisions.
| Layer | Technology |
|---|---|
| Framework | Next.js 15 (App Router) |
| Language | TypeScript (strict mode) |
| Styling | Tailwind CSS v4 |
| Components | shadcn/ui + Radix UI |
| Drag & Drop | @dnd-kit |
| Validation | Zod |
| Testing | Vitest |
| Storage | Local JSON files (~/.cmc/) |
| Agent CLIs | Claude Code, Codex CLI |
Run from inside mission-control/:
pnpm dev # Start dev server (http://localhost:3000)
pnpm build # Production build
pnpm test # Run test suite
pnpm verify # Typecheck + lint + build + test
pnpm daemon:start # Start Autopilot daemon
pnpm daemon:stop # Stop Autopilot daemon
pnpm daemon:status # Show daemon status + active sessions
pnpm gen:context # Regenerate ~/.cmc/ai-context.md
pnpm cleanup:uploads # Remove orphaned files from ~/.cmc/uploadsBuilt on Mission Control by Dan Meisner.
AGPL-3.0: free to use, modify, and self-host. If you offer it as a hosted service, you must open-source your modifications under the same license.
Your AI agents work. You decide.