AI Agent Orchestration Dashboard
Create tasks. Plan with AI. Dispatch to agents. Watch them work.
Quick Start • Docker • Features • How It Works • Configuration
- Agent Activity Dashboard — Dedicated view for monitoring agent work in real-time, with mobile-optimized card layout
- Remote Model Discovery — Discover and select AI models directly from your OpenClaw Gateway (
MODEL_DISCOVERY=true) - Dispatch Recovery — Tasks stuck in
pending_dispatchnow auto-reset to planning so you can retry - Planning Spec Forwarding — Dispatch messages now include the full planning spec and agent instructions
See the full CHANGELOG for details.
OpenMissionControl is runtime-agnostic and works with multiple AI agent orchestration backends:
- OSA — Optimal System Agent
- OpenClaw — Full-featured AI gateway with WebSocket orchestration
- NanoClaw — Lightweight agent runtime for local development
- IronClaw — Enterprise-grade agent runtime with advanced security
- Any WebSocket-compatible agent runtime — Extensible architecture supports custom backends
The default integration uses OpenClaw Gateway, but the dispatch and session management layer can be adapted to any compatible runtime.
Task Management — Kanban board with drag-and-drop across 7 status columns
AI Planning — Interactive Q&A flow where AI asks clarifying questions before starting work
Agent System — Auto-creates specialized agents, assigns tasks, tracks progress in real-time
Gateway Agent Discovery — Import existing agents from your OpenClaw Gateway with one click
OpenClaw Integration — WebSocket connection to OpenClaw Gateway for AI agent orchestration
Docker Ready — Production-optimized Dockerfile and docker-compose for easy deployment
Security First — Bearer token auth, HMAC webhooks, Zod validation, path traversal protection, security headers
Live Feed — Real-time event stream showing agent activity, task updates, and system events
Multi-Machine — Run the dashboard and AI agents on different computers (supports Tailscale for remote)
┌──────────────────────────────────────────────────────────────┐
│ YOUR MACHINE │
│ │
│ ┌─────────────────┐ ┌──────────────────────────┐ │
│ │ Mission Control │◄────────►│ OpenClaw Gateway │ │
│ │ (Next.js) │ WS │ (AI Agent Runtime) │ │
│ │ Port 4000 │ │ Port 18789 │ │
│ └────────┬─────────┘ └───────────┬──────────────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────────────┐ ┌──────────────────────────┐ │
│ │ SQLite │ │ AI Provider │ │
│ │ Database │ │ (Anthropic / OpenAI) │ │
│ └─────────────────┘ └──────────────────────────┘ │
└──────────────────────────────────────────────────────────────┘
OpenMissionControl = The dashboard you interact with (this project) OpenClaw Gateway = The AI runtime that executes tasks (separate project)
OpenMissionControl includes an interactive setup guide at /setup that walks through:
- Prerequisites and installation
- Environment configuration
- Gateway connection verification (with live status check)
- Agent setup (import, manual, or auto-generated)
- Security configuration
Access it at http://localhost:4000/setup after starting the server.
- Node.js v18+ (download)
- OpenClaw Gateway —
npm install -g openclaw - AI API Key — Anthropic (recommended), OpenAI, Google, or others via OpenRouter
# Clone
git clone https://github.com/robertohluna/open-mission-control.git
cd open-mission-control
# Install dependencies
npm install
# Configure
cp .env.example .env.localEdit .env.local:
OPENCLAW_GATEWAY_URL=ws://127.0.0.1:18789
OPENCLAW_GATEWAY_TOKEN=your-token-hereWhere to find the token: Check
~/.openclaw/openclaw.jsonundergateway.token
# Start OpenClaw (separate terminal)
openclaw gateway start
# Start OpenMissionControl
npm run devOpen http://localhost:4000 — you're in!
npm run build
npx next start -p 4000You can run OpenMissionControl in a container using the included Dockerfile and docker-compose.yml.
- Docker Desktop (or Docker Engine + Compose plugin)
- OpenClaw Gateway running locally or remotely
Create a .env file for Compose:
cp .env.example .envThen set at least:
OPENCLAW_GATEWAY_URL=ws://host.docker.internal:18789
OPENCLAW_GATEWAY_TOKEN=your-token-hereNotes:
- Use
host.docker.internalwhen OpenClaw runs on your host machine. - If OpenClaw is on another machine, set its reachable
ws://orwss://URL instead.
docker compose up -d --buildOpen http://localhost:4000.
# View logs
docker compose logs -f mission-control
# Stop containers
docker compose down
# Stop and remove volumes (deletes SQLite/workspace data)
docker compose down -vCompose uses named volumes:
mission-control-datafor SQLite (/app/data)mission-control-workspacefor workspace files (/app/workspace)
CREATE PLAN ASSIGN EXECUTE DELIVER
┌────────┐ ┌────────┐ ┌────────────┐ ┌──────────┐ ┌────────┐
│ New │───►│ AI │───►│ Agent │───►│ Agent │───►│ Done │
│ Task │ │ Q&A │ │ Created │ │ Works │ │ │
└────────┘ └────────┘ └────────────┘ └──────────┘ └────────┘
- Create a Task — Give it a title and description
- AI Plans It — The AI asks you clarifying questions to understand exactly what you need
- Agent Assigned — A specialized agent is auto-created based on your answers
- Work Happens — The agent writes code, browses the web, creates files — whatever's needed
- Delivery — Completed work shows up in OpenMissionControl with deliverables
PLANNING → INBOX → ASSIGNED → IN PROGRESS → TESTING → REVIEW → DONE
Drag tasks between columns or let the system auto-advance them.
OpenMissionControl includes an agent learning system that improves agent performance over time:
- Agent Learnings — On task completion, the system extracts patterns from activities and deliverables, storing them in the
agent_learningstable - Planning Q&A Forwarding — When tasks are dispatched, answered planning questions are included as "User Requirements" context
- Activity History — Recent activity logs are forwarded during dispatch, giving agents awareness of prior work
- Learning API —
GET/POST /api/agents/[id]/learningsfor programmatic access to agent learnings
| Variable | Required | Default | Description |
|---|---|---|---|
OPENCLAW_GATEWAY_URL |
Yes | ws://127.0.0.1:18789 |
WebSocket URL to OpenClaw Gateway |
OPENCLAW_GATEWAY_TOKEN |
Yes | — | Authentication token for OpenClaw |
MC_API_TOKEN |
— | — | API auth token (enables auth middleware) |
WEBHOOK_SECRET |
— | — | HMAC secret for webhook validation |
DATABASE_PATH |
— | ./mission-control.db |
SQLite database location |
WORKSPACE_BASE_PATH |
— | ~/Documents/Shared |
Base directory for workspace files |
PROJECTS_PATH |
— | ~/Documents/Shared/projects |
Directory for project folders |
Generate secure tokens:
# API authentication token
openssl rand -hex 32
# Webhook signature secret
openssl rand -hex 32Add to .env.local:
MC_API_TOKEN=your-64-char-hex-token
WEBHOOK_SECRET=your-64-char-hex-tokenWhen MC_API_TOKEN is set:
- External API calls require
Authorization: Bearer <token> - Browser UI works automatically (same-origin requests are allowed)
- SSE streams accept token as query param
See PRODUCTION_SETUP.md for the full production guide.
Run OpenMissionControl on one machine and OpenClaw on another:
# Point to the remote machine
OPENCLAW_GATEWAY_URL=ws://YOUR_SERVER_IP:18789
OPENCLAW_GATEWAY_TOKEN=your-shared-tokenOPENCLAW_GATEWAY_URL=wss://your-machine.tailnet-name.ts.net
OPENCLAW_GATEWAY_TOKEN=your-shared-tokenSQLite database auto-created at ./mission-control.db.
# Reset (start fresh)
rm mission-control.db
# Inspect
sqlite3 mission-control.db ".tables"open-mission-control/
├── src/
│ ├── app/ # Next.js pages & API routes
│ │ ├── api/
│ │ │ ├── tasks/ # Task CRUD + planning + dispatch
│ │ │ ├── agents/
│ │ │ │ └── [id]/
│ │ │ │ └── learnings/route.ts # Agent learnings API
│ │ │ ├── openclaw/ # Gateway proxy endpoints
│ │ │ └── webhooks/ # Agent completion webhooks
│ │ ├── setup/page.tsx # Interactive setup guide
│ │ ├── settings/ # Settings page
│ │ └── workspace/[slug]/ # Workspace dashboard
│ ├── components/
│ │ ├── ui/
│ │ │ ├── StatusBadge.tsx # Reusable status badge atom
│ │ │ └── PriorityDot.tsx # Priority indicator atom
│ │ ├── MissionQueue.tsx # Kanban board
│ │ ├── PlanningTab.tsx # AI planning interface
│ │ ├── AgentsSidebar.tsx # Agent panel
│ │ ├── LiveFeed.tsx # Real-time events
│ │ └── TaskModal.tsx # Task create/edit
│ └── lib/
│ ├── db/ # SQLite + migrations
│ ├── openclaw/ # Gateway client + device identity
│ ├── agent-learning.ts # Learning extraction & storage
│ ├── logger.ts # Structured logger (replaces console.log)
│ ├── cn.ts # Tailwind class merge utility
│ ├── validation.ts # Zod schemas
│ └── types.ts # TypeScript types
├── scripts/ # Bridge & hook scripts
├── src/middleware.ts # Auth middleware
├── .env.example # Environment template
└── CHANGELOG.md # Version history
- Check OpenClaw is running:
openclaw gateway status - Verify URL and token in
.env.local - Check firewall isn't blocking port 18789
- Check OpenClaw logs:
openclaw gateway logs - Verify your AI API key is valid
- Refresh and click the task again
lsof -i :4000
kill -9 <PID>If you're behind an HTTP proxy (corporate VPN, Hiddify, etc.), agent callbacks to localhost may fail because the proxy intercepts local requests.
Fix: Set NO_PROXY so localhost bypasses the proxy:
# Linux / macOS
export NO_PROXY=localhost,127.0.0.1
# Windows (cmd)
set NO_PROXY=localhost,127.0.0.1
# Docker
docker run -e NO_PROXY=localhost,127.0.0.1 ...- Fork the repository
- Create a feature branch:
git checkout -b feature/amazing-feature - Commit your changes:
git commit -m 'feat: add amazing feature' - Push:
git push origin feature/amazing-feature - Open a Pull Request
MIT License — see LICENSE for details.
