Self-Hosted Multi-Agent Orchestration with Mission Control: Production Patterns
Running agents in production means moving past single-session REPLs and into coordinated fleets. When you have five agents running different tasks — research, code review, deployment, monitoring — you need a control plane. Not another CLI wrapper, but a dashboard that shows what each agent is doing, how much it’s costing, and whether anything went wrong while you were asleep.
Mission Control (builderz-labs/mission-control, MIT license, 5.2k stars) solves exactly this: a self-hosted orchestration dashboard with zero external dependencies. One pnpm start gives you task boards, cost tracking, agent discovery, knowledge graphs, security scanning, and six framework adapters. This post walks its architecture and the production patterns worth adopting.
Architecture: Zero External Dependencies
The most interesting design decision in Mission Control is its dependency profile. No Redis, no Postgres, no external message bus. SQLite with WAL mode handles persistence. A single process serves the full stack.
git clone https://github.com/builderz-labs/mission-control.git
cd mission-control
pnpm install
cp .env.example .env
pnpm devThis matters for teams that can’t justify a dedicated infrastructure layer for their agent orchestration. If you’re running 2-10 agents, standing up a Redis cluster and Postgres instance just to track task state is overkill. Mission Control’s approach — Next.js 16, React 19, TypeScript, SQLite — keeps the operational surface small.
The tradeoff is horizontal scaling: SQLite WAL mode supports concurrent readers but single-writer. For teams scaling beyond ~50 concurrent agent tasks, a Postgres-backed alternative like LangGraph or Temporal makes more sense [1]. But for small-to-medium agent fleets, the zero-dependency bet pays off in deployment simplicity.
Task Board and Dispatch Patterns
The task board implements a six-column kanban: Inbox → Assigned → In Progress → Review → Quality Review → Done. Each transition is an API call, and the system enforces atomic task claims:
UPDATE tasks SET status = 'in_progress', assigned_to = ?
WHERE id = ? AND status = 'assigned'This atomic UPDATE prevents double-dispatch — two agents can’t claim the same task. It’s a simple pattern but frequently missed in homegrown orchestration. The same approach is used in job queues like GoodJob and Sidekiq, and porting it into an agent context avoids the race conditions that plague naive task assignment [2].
Recurring tasks use a natural language scheduler (“every morning at 9am”) that converts to cron expressions, then clones a template task on each trigger. The template-clone pattern means each recurring run is a full-fledged task with its own history, unlike a simple cron script that has no audit trail.
Framework Adapters: The Multi-Gateway Pattern
Mission Control supports six agent frameworks through a normalized adapter interface:
| Framework | Registration | Heartbeat | Task Reporting |
|---|---|---|---|
| OpenClaw | Gateway API | /heartbeat | /tasks/report |
| CrewAI | Gateway API | /heartbeat | /tasks/report |
| LangGraph | Gateway API | /heartbeat | /tasks/report |
| AutoGen | Gateway API | /heartbeat | /tasks/report |
| Claude SDK | Built-in | Session scan | Session bridge |
| Generic | Custom adapter | Custom | Custom |
The multi-gateway approach lets you run a LangGraph agent and a CrewAI agent side by side, both reporting to the same dashboard. This is uncommon — most frameworks assume a single runtime. Mission Control’s gateway abstraction normalizes registration, heartbeats, and task reporting so the control plane doesn’t care which framework produced the agent.
Claude Code integration is particularly well-implemented: it auto-discovers sessions from ~/.claude/projects/, extracts tokens and model info, and surfaces tasks read-only. This means existing Claude Code workflows don’t need modification to be visible in the dashboard.
Security Panel and Production Guardrails
The security audit panel is where Mission Control exceeds most orchestration dashboards. It includes:
- Secrets scanner: regex-based detection for AWS keys, GitHub tokens, JWTs, database URIs in agent configurations
- Injection guard: prompt and command injection scanning on workflows, spawn requests, and chat — 42 unit tests covering edge cases
- SSRF hardening: IPv4 CIDR blocking for private ranges (10/8, 172.16/12, 192.168/16, 127/8, 169.254/16) with host allowlisting
- Rate limiting: per-agent (30 req/min heartbeat, 20 req/min task polling) and per-IP (5/min self-registration)
- Supply-chain: 7-day cooldown on Dependabot updates and pnpm minimumReleaseAge for dependency hygiene
These aren’t theoretical. Prompt injection through task descriptions is a real vector — an agent reading a poisoned task description could act on instructions hidden in the text. The injection guard scans all workflow inputs before they reach the agent, which is the right place to block it [3].
Cost Tracking with Per-Model Breakdown
The cost tracker provides per-agent, per-session, per-model token breakdowns with trend charts. Mission Control maintains its own pricing tables for providers:
// Opus 4.5 pricing correction (v2.0.1)
pricing: {
"opus-4-5": { input: 5, output: 25 }, // per MTok
"haiku-4-5": { input: 1, output: 5 },
}This matters because agent costs are invisible without a tracking layer. A single LangGraph agent running 50 tool-calling iterations with a 128K context window can burn through $5-10 in tokens before anyone notices. Mission Control’s unified cost panel surfaces these costs at the task level, making it possible to identify expensive agent runs and optimize prompt strategies.
Production Deployment Patterns
The recommended deployment is docker compose with a bind-mounted SQLite volume:
services:
mission-control:
image: ghcr.io/builderz-labs/mission-control:latest
ports:
- "3000:3000"
environment:
- ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
- OPENAI_API_KEY=${OPENAI_API_KEY}
- JWT_SECRET=${JWT_SECRET}
volumes:
- ./data:/app/data
- $HOME/.claude:/home/node/.claude:roKey environment configurations:
| Variable | Purpose |
|---|---|
MC_COORDINATOR_AGENT | Auto-route unassigned tasks to a specific agent |
MC_CLAUDE_SCAN_INTERVAL_MS | How often to scan for Claude Code sessions (default: 30000) |
MC_MAX_SESSION_FILE_BYTES | Max session file size to parse |
The self-update endpoint (POST /api/admin/update) runs git pull, installs dependencies, and rebuilds — useful for unattended upgrades inside a trusted network.
When to Use Mission Control vs. Alternatives
| Criterion | Mission Control | LangGraph | Temporal |
|---|---|---|---|
| Setup time | 10 minutes | 30 min + Postgres | 1 hour + infra |
| Agent fleet size | 1-20 | 1-100 | 10-1000+ |
| Framework support | 6 adapters | LangGraph only | Custom |
| Observability | Built-in | Via LangSmith | Via Temporal UI |
| State persistence | SQLite | Postgres | Cassandra/Postgres |
| License | MIT | MIT | MIT |
Mission Control fills the gap between ad-hoc agent scripts and heavy-duty orchestration runtimes. If you’re running a handful of agents and want a unified dashboard without infrastructure overhead, it’s the right choice. If you need durable workflow execution with retries and compensation logic (think payment processing, multi-step approvals), Temporal or LangGraph with checkpointing is more appropriate [4].
The Takeaway
Self-hosted orchestration is becoming a standard layer in the agent stack, and Mission Control proves it can be done with minimal infrastructure. The zero-dependency architecture, multi-framework adapters, and security-first design make it a practical choice for teams running production agents.
The most portable pattern here isn’t the code — it’s the approach: normalize agent registration across frameworks, enforce atomic task claims, scan every input for injection, and surface costs at the task level. These patterns apply whether you use Mission Control or build your own control plane.
Related Reads
- AI Agent Observability in Production: The Complete Guide for 2026
- Multi-Agent Orchestration Platforms: Build vs Buy in 2026
- 10 Best AI Agent Orchestration Tools in 2026
- Self-Healing CI/CD Automation Patterns for Agent Deployments
- Hermes Agent Multi-Agent Setup Guide 2026
- Build Log: Multi-Agent Research Pipeline with OpenClaw
- The Agent Service Mesh: Production Patterns for Inter-Agent Communication
[1] Gartner, “Market Guide for AI Orchestration Platforms,” February 2026. https://www.gartner.com/en/documents/ai-orchestration-platforms-market-guide-2026
[2] Mike Perham, “Reliable Job Queues with Atomic Claims,” Sidekiq Architecture Docs. https://github.com/sidekiq/sidekiq/wiki/Reliable-Queues
[3] OWASP, “LLM Prompt Injection Mitigation Strategies,” OWASP Top 10 for LLM Applications v2.0, 2026. https://genai.owasp.org/llm-top-10/
[4] Augment Code, “7 Multi-Agent Orchestration Platforms: Build vs Buy in 2026.” https://www.augmentcode.com/tools/multi-agent-orchestration-platforms-build-vs-buy
← Back to all posts
