Mission Control

Tame the swarm. Ship what matters.

Open-source command center for solo entrepreneurs who delegate work to AI agents.

Idea · · · Research · · · Go / No-Go · · · Build MVP · · · Launch

You jot down a raw idea. Agents research the market and deliver a go/no-go report.

You give the green light. Agents build the MVP. You review it and say ship it.

**They deploy the app, post to social media, run ad campaigns,

set up payments, and keep it running.**

You made three decisions. They did everything else.

Why This Exists

Right now, everyone is releasing autonomous AI agents into the wild. It's a Cambrian explosion — agent swarms spinning up, executing tasks, calling APIs, moving money, posting content. It's exhilarating. It's also like herding wild horses. Powerful, untamed, and running in every direction. Credentials are leaking. Agents are operating as black boxes. Nobody can tell you what's actually running, whether it finished, or if it went off the rails three hours ago.

I'm a serial entrepreneur with way more ideas than hours in the day, and nowhere near enough resources to pursue them all traditionally. I built Mission Control because I was drowning — not in work, but in the chaos of trying to manage it all. I wanted my time back. Time with my family. Time actually living — not trading my finite heartbeats for a paycheck. AI agents are the greatest force multiplier a solo founder has ever had. But unleashing baby AGIs into the wild without structure? That's not leverage. That's a liability.

Mission Control is the fenced playground where your AI agents can run wild — but safely. It's the bridge between you and your swarm. Agents get roles, inboxes, and reporting protocols. You capture a raw idea in the brain dump, agents research it, build the MVP, and Field Ops launches it into the world — with approval workflows and spend limits at every step. You stay in control without micromanaging. You see everything. You ship what matters.

How is this different from Linear, Asana, or Notion? Those tools were built for humans typing into forms. Mission Control was built agent-first — from day one, for a world where AI agents do the work and humans make the decisions. Agents read and write tasks through a token-optimized API, report progress to your inbox, and escalate to you when they need judgment. You manage outcomes, not keystrokes. And it runs locally — no cloud dependency, no API keys leaked to third parties, no vendor lock-in.

Features

• Eisenhower Matrix — Prioritize by importance and urgency with drag-and-drop between quadrants
• Kanban Board — Track work through Not Started, In Progress, and Done columns
• Goal Hierarchy — Long-term goals with milestone tracking, progress bars, and linked tasks
• Brain Dump — Capture ideas instantly, triage into tasks later
• Agent Crew — 6 built-in agents + create unlimited custom agents with unique instructions
• Skills Library — Define reusable knowledge modules and inject them into agent prompts
• Multi-Agent Tasks — Assign a lead agent + collaborators for team-based work
• Orchestrator — Run /orchestrate to spawn all agents on pending work simultaneously
• Autonomous Daemon — Background process that automatically polls tasks, spawns Claude Code sessions, enforces concurrency, and provides a real-time dashboard
• One-Click Execution — Press play on any task card to spawn a Claude Code session; live status indicators, success/failure toasts, and automatic completion (task → done, inbox report, activity log)
• Session Resilience — Agents that timeout or hit max turns automatically re-spawn continuation sessions, preserving progress in task notes and subtasks. Configurable max continuations per task and per inbox response
• Cost & Usage Tracking — Captures cost and full token usage (input, output, cache read, cache creation) from every Claude Code session; displayed on the Autopilot dashboard with per-task cost breakdown and running totals
• Failure Logging — Failed tasks generate task_failed activity events with error details, session count, and agent info. Failure reports are automatically posted to your inbox
• Inbox Stop Button — Stop an agent mid-response with a single click; kills the process tree and prevents continuation chains from spawning
• Continuous Missions — Run an entire project with one click; tasks auto-dispatch as others complete, respect dependency chains, and skip decision-blocked work. Real-time progress bar with stop button
• Loop Detection — Auto-detects agents stuck in failure loops; after 3 attempts, escalates to a user decision with options to retry differently, skip, or stop
• Token-Optimized API — Filtered queries, sparse field selection, 92% context compression (~50 tokens vs ~5,400)
• Inbox & Decisions — Full agent communication layer: delegation, reports, questions, and approvals
• Cmd+K Search — Global search across tasks, projects, goals, and brain dump entries
• Error Resilience — Error boundaries on every page with retry buttons, plus global error handler for crash recovery
• API Pagination — All 9 GET endpoints support limit and offset with a meta object (total, filtered, returned)
• 193 Automated Tests — Vitest suite covering validation schemas, data layer operations, and full agent communication flow
• Skills Injection — Skills from the library are embedded into agent command files bidirectionally (agent→skill and skill→agent)
• Accessibility — ARIA live regions for drag-and-drop screen reader announcements, focus trapping on detail panels
• CI Pipeline — GitHub Actions runs typecheck, lint, build, and tests on every push and PR

Field Ops — External Action Execution

• 64-Service Catalog — Pre-configured services across 16 categories with setup guides
• 3 Working Adapters — X, Ethereum (+ MetaMask wallet signing), Reddit
• Encrypted Vault — AES-256-GCM encryption with scrypt key derivation
• Financial Safety Controls — Per-service + global spend limits, circuit breaker (master-password-protected)
• 3 Autonomy Levels — Manual Approval, Supervised, Full Autonomy
• Approval Workflows — Risk classification + approval queue for high-risk actions
• Dry Run Testing — Validate actions without executing + auto-staleness checks
• Mission System — Group related tasks into missions with progress tracking
• Emergency Stop — Kill switch that instantly halts daemon, pauses missions, and locks the vault
• PM2 Support — Always-on mode with auto-restart on crash (ecosystem.config.js included)
• Master-Password-Protected Controls — Autonomy levels, safety limits, and daemon launch require vault password
• Safety Dashboard — Centralized per-service and global spend limits with circuit breaker

Quick Start

Prerequisites

The web UI works standalone for task management, prioritization, and goal tracking. Claude Code is needed to execute tasks via agents. Any AI coding tool that can access local files (Cursor, Windsurf, etc.) can also participate — see Works With below.

Install & Run

git clone https://github.com/MeisnerDan/mission-control.git
cd mission-control/mission-control   # repo folder → app folder (where package.json lives)
pnpm install
pnpm dev

# Always-on mode (optional, auto-restarts on crash)
pm2 start ecosystem.config.js

Open http://localhost:3000 and click "Load Demo Data" to see it in action with sample tasks, agents, and messages.

What to Try First

1. Explore the dashboard — see task counts, agent workloads, and recent activity at a glance
2. Drag tasks on the Priority Matrix — move tasks between Do, Schedule, Delegate, and Eliminate
3. Click a task card to open the detail panel — edit description, subtasks, and acceptance criteria
4. Click the 🚀 Launch button on a task assigned to an agent — spawns a Claude Code session that executes the work (requires Claude Code)
5. Open Claude Code in this workspace and run /daily-plan to see slash commands in action

How It Works

Mission Control stores all data in local JSON files. No database, no cloud dependency. AI agents interact by reading and writing these files — the same source of truth the web UI uses.

The Agent Loop

1. You create a task          ──>  Assign to an agent role (e.g., Researcher)
2. Press play (or daemon)     ──>  Spawns a Claude Code session with agent persona
3. Agent executes             ──>  Does the work, updates progress
4. Mission Control completes  ──>  Auto-marks done, posts report, logs activity
5. You review                 ──>  Read reports in inbox, answer questions

Multiple agents can work in parallel across different tasks. Continuous missions take this further — click the rocket button on a project to run all tasks until done. As each task completes, the next batch auto-dispatches, respecting dependency chains and concurrency limits. If an agent gets stuck, loop detection escalates to you after 3 failures. The daemon (pnpm daemon:start) adds 24/7 background automation, polling for new tasks and running scheduled commands on cron schedules.

Testing

Mission Control includes 193 automated tests across 3 suites:

pnpm test        # Run all tests
pnpm check       # Typecheck + lint
pnpm verify      # Full verification: typecheck + lint + build + test

Agent API

Every API endpoint is designed for minimal token consumption. Your agents spend tokens doing work, not parsing bloated payloads.

# Get only your in-progress tasks (~50 tokens vs ~5,400 for everything)
GET /api/tasks?assignedTo=developer&kanban=in-progress

# Sparse fields — return only what you need
GET /api/tasks?fields=id,title,kanban

# Get just the DO quadrant (important + urgent)
GET /api/tasks?quadrant=do

# Paginated results with metadata
GET /api/tasks?limit=10&offset=0
# → { data: [...], meta: { total: 47, filtered: 47, returned: 10, limit: 10, offset: 0 } }

# Compressed context — entire workspace state in ~650 tokens
# (vs ~10,000+ for raw JSON files)
pnpm gen:context  # outputs data/ai-context.md

# Run a single task — spawns a Claude Code session
POST /api/tasks/:id/run

# Run all eligible tasks in a project as a continuous mission
POST /api/projects/:id/run

# Stop a running mission (kills all processes, resets tasks)
POST /api/projects/:id/stop

# Stop a single running task
POST /api/tasks/:id/stop

# Get live status of all active runs
GET /api/runs

# Get mission status (with auto-reconciliation of stuck missions)
GET /api/missions

# Check status of inbox auto-respond sessions
GET /api/inbox/respond/status?messageId=msg_123

# Stop an active inbox auto-respond chain
POST /api/inbox/respond/stop

F