MCPInstall

openclaw-mission-control

by reason-machinesAI & Agents

AI Agent Orchestration Dashboard for managing AI agents, tasks, and multi-agent collaboration via OpenClaw Gateway

Installs
174
Last 24h
—
Trending rank
—
Security
Not audited

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/reason-machines/hermes-skills --skill openclaw-mission-control
  1. 01

    Install

    Run the command in your project. The CLI asks which agents to install for.

  2. 02

    Describe the task

    Ask your agent for something this skill covers. It loads openclaw-mission-control automatically when relevant.

  3. 03

    Review the result

    The agent follows the SKILL.md steps, scripts and references bundled with the skill.

SKILL.md

The instructions your agent reads when the skill is triggered.

OpenClaw Mission Control

Skill by ara.so — Hermes Skills collection.

OpenClaw Mission Control is a centralized operations and governance platform for AI agent orchestration. It provides a unified dashboard for managing AI agents, assigning tasks, coordinating multi-agent collaboration, and implementing approval-driven governance. Built with TypeScript, it offers both web UI and API-first access for automation.

What It Does

Mission Control serves as a control plane for OpenClaw operations:

  • Work Orchestration: Manage organizations, board groups, boards, tasks, and tags in hierarchical structures
  • Agent Operations: Create, inspect, and manage agent lifecycle from a unified interface
  • Governance & Approvals: Route sensitive actions through explicit approval workflows with audit trails
  • Gateway Management: Connect and operate distributed execution environments and gateway integrations
  • Activity Visibility: Review complete timeline of system actions for debugging and accountability
  • API-First Design: Support both web workflows and automation clients from the same platform

Installation

Quick Start with Installer

# One-line installation (clones repo if needed)
curl -fsSL https://raw.githubusercontent.com/abhi1693/openclaw-mission-control/master/install.sh | bash

# Or if you already cloned the repo
./install.sh

The installer is interactive and handles:

  • Deployment mode selection (Docker or local)
  • System dependency installation
  • Environment file generation
  • Bootstrap and startup

Manual Docker Setup

# Clone repository
git clone https://github.com/abhi1693/openclaw-mission-control.git
cd openclaw-mission-control

# Configure environment
cp .env.example .env

# Edit .env and set required values:
# - LOCAL_AUTH_TOKEN (minimum 50 characters)
# - BASE_URL (backend origin)
# - NEXT_PUBLIC_API_URL (frontend API endpoint)

# Start services
docker compose -f compose.yml --env-file .env up -d --build

Manual Local Setup

Prerequisites: Node.js 22+, PostgreSQL, Redis

# Backend setup
cd backend
cp .env.example .env
# Edit .env with database credentials and auth config
npm install
npm run db:migrate
npm run dev

# Frontend setup (in new terminal)
cd frontend
cp .env.example .env
# Edit .env with API URL
npm install
npm run dev

Access:

Authentication Configuration

Mission Control supports two authentication modes:

Local Token Mode (Default for Self-Hosted)

# .env
AUTH_MODE=local
LOCAL_AUTH_TOKEN=your-secure-token-minimum-50-characters-required

Use in API requests:

curl -H "Authorization: Bearer ${LOCAL_AUTH_TOKEN}" \
  http://localhost:8000/api/organizations

Clerk JWT Mode

# .env
AUTH_MODE=clerk
CLERK_PUBLISHABLE_KEY=${CLERK_PUBLISHABLE_KEY}
CLERK_SECRET_KEY=${CLERK_SECRET_KEY}

# frontend/.env
NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=${CLERK_PUBLISHABLE_KEY}

Core Concepts

Hierarchy Structure

Organization
  └── Board Group
      └── Board
          └── Task
              └── Tag (optional)

Agent Lifecycle

  1. Creation: Define agent with name, description, capabilities
  2. Assignment: Link agent to boards and tasks
  3. Execution: Agent processes tasks according to workflow
  4. Approval: Sensitive actions require explicit approval
  5. Audit: All actions logged in activity timeline

API Usage

Organizations

// Create organization
const createOrganization = async (token: string) => {
  const response = await fetch('http://localhost:8000/api/organizations', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      name: 'Engineering Team',
      description: 'Primary engineering organization',
    }),
  });
  return response.json();
};

// List organizations
const listOrganizations = async (token: string) => {
  const response = await fetch('http://localhost:8000/api/organizations', {
    headers: {
      'Authorization': `Bearer ${token}`,
    },
  });
  return response.json();
};

Board Groups

// Create board group
const createBoardGroup = async (token: string, orgId: string) => {
  const response = await fetch('http://localhost:8000/api/board-groups', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      organization_id: orgId,
      name: 'Q1 2026 Projects',
      description: 'First quarter project boards',
    }),
  });
  return response.json();
};

Boards

// Create board
const createBoard = async (token: string, groupId: string) => {
  const response = await fetch('http://localhost:8000/api/boards', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      board_group_id: groupId,
      name: 'API Development',
      description: 'Backend API development tasks',
    }),
  });
  return response.json();
};

// Get board with tasks
const getBoard = async (token: string, boardId: string) => {
  const response = await fetch(`http://localhost:8000/api/boards/${boardId}`, {
    headers: {
      'Authorization': `Bearer ${token}`,
    },
  });
  return response.json();
};

Tasks

// Create task
const createTask = async (token: string, boardId: string) => {
  const response = await fetch('http://localhost:8000/api/tasks', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      board_id: boardId,
      title: 'Implement user authentication',
      description: 'Add JWT-based authentication to API endpoints',
      status: 'todo',
      priority: 'high',
      assigned_agent_id: null, // Optional agent assignment
    }),
  });
  return response.json();
};

// Update task status
const updateTaskStatus = async (token: string, taskId: string, status: string) => {
  const response = await fetch(`http://localhost:8000/api/tasks/${taskId}`, {
    method: 'PATCH',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      status, // 'todo' | 'in_progress' | 'review' | 'done'
    }),
  });
  return response.json();
};

Agents

// Create agent
const createAgent = async (token: string) => {
  const response = await fetch('http://localhost:8000/api/agents', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      name: 'Code Review Agent',
      description: 'Automated code review and quality checks',
      capabilities: ['code-analysis', 'security-scan', 'style-check'],
      config: {
        model: 'gpt-4',
        temperature: 0.3,
        max_tokens: 2000,
      },
    }),
  });
  return response.json();
};

// Assign agent to task
const assignAgent = async (token: string, taskId: string, agentId: string) => {
  const response = await fetch(`http://localhost:8000/api/tasks/${taskId}`, {
    method: 'PATCH',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      assigned_agent_id: agentId,
    }),
  });
  return response.json();
};

Approvals

// Request approval for sensitive action
const requestApproval = async (token: string, taskId: string) => {
  const response = await fetch('http://localhost:8000/api/approvals', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      task_id: taskId,
      action: 'deploy_to_production',
      reason: 'Deploy feature to production environment',
      metadata: {
        environment: 'production',
        service: 'api-gateway',
      },
    }),
  });
  return response.json();
};

// Approve or reject
const processApproval = async (token: string, approvalId: string, approved: boolean) => {
  const response = await fetch(`http://localhost:8000/api/approvals/${approvalId}`, {
    method: 'PATCH',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      status: approved ? 'approved' : 'rejected',
      comment: approved ? 'LGTM' : 'Needs additional testing',
    }),
  });
  return response.json();
};

Gateway Management

// Register gateway
const registerGateway = async (token: string) => {
  const response = await fetch('http://localhost:8000/api/gateways', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      name: 'Production Gateway',
      endpoint: 'https://gateway.example.com',
      auth_token: process.env.GATEWAY_AUTH_TOKEN,
      capabilities: ['task-execution', 'log-streaming'],
    }),
  });
  return response.json();
};

// Execute task via gateway
const executeViaGateway = async (token: string, gatewayId: string, taskId: string) => {
  const response = await fetch(`http://localhost:8000/api/gateways/${gatewayId}/execute`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      task_id: taskId,
      parameters: {
        environment: 'production',
      },
    }),
  });
  return response.json();
};

Activity Timeline

// Get activity log
const getActivity = async (token: string, filters?: object) => {
  const params = new URLSearchParams(filters as Record<string, string>);
  const response = await fetch(`http://localhost:8000/api/activity?${params}`, {
    headers: {
      'Authorization': `Bearer ${token}`,
    },
  });
  return response.json();
};

// Get activity for specific resource
const getResourceActivity = async (token: string, resourceType: string, resourceId: string) => {
  const response = await fetch(
    `http://localhost:8000/api/activity?resource_type=${resourceType}&resource_id=${resourceId}`,
    {
      headers: {
        'Authorization': `Bearer ${token}`,
      },
    }
  );
  return response.json();
};

Common Patterns

Multi-Agent Workflow

// Create workflow with multiple agents
const createMultiAgentWorkflow = async (token: string) => {
  // 1. Create organization and board
  const org = await createOrganization(token);
  const group = await createBoardGroup(token, org.id);
  const board = await createBoard(token, group.id);
  
  // 2. Create specialized agents
  const codeAgent = await createAgent(token, {
    name: 'Code Generator',
    capabilities: ['code-generation'],
  });
  
  const reviewAgent = await createAgent(token, {
    name: 'Code Reviewer',
    capabilities: ['code-review'],
  });
  
  const testAgent = await createAgent(token, {
    name: 'Test Runner',
    capabilities: ['test-execution'],
  });
  
  // 3. Create sequential tasks
  const codeTask = await createTask(token, board.id, {
    title: 'Generate feature code',
    assigned_agent_id: codeAgent.id,
  });
  
  const reviewTask = await createTask(token, board.id, {
    title: 'Review generated code',
    assigned_agent_id: reviewAgent.id,
    dependencies: [codeTask.id],
  });
  
  const testTask = await createTask(token, board.id, {
    title: 'Run integration tests',
    assigned_agent_id: testAgent.id,
    dependencies: [reviewTask.id],
  });
  
  return { board, tasks: [codeTask, reviewTask, testTask] };
};

Approval-Gated Deployment

// Deployment with approval requirement
const deployWithApproval = async (token: string, taskId: string) => {
  // 1. Request approval
  const approval = await requestApproval(token, taskId);
  
  // 2. Wait for approval (polling or webhook)
  let approvalStatus = approval;
  while (approvalStatus.status === 'pending') {
    await new Promise(resolve => setTimeout(resolve, 5000));
    const response = await fetch(
      `http://localhost:8000/api/approvals/${approval.id}`,
      { headers: { 'Authorization': `Bearer ${token}` } }
    );
    approvalStatus = await response.json();
  }
  
  // 3. Execute if approved
  if (approvalStatus.status === 'approved') {
    await fetch(`http://localhost:8000/api/tasks/${taskId}/execute`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });
    return { success: true };
  }
  
  return { success: false, reason: approvalStatus.comment };
};

Gateway-Based Distributed Execution

// Execute tasks across multiple gateways
const distributeExecution = async (token: string, tasks: any[], gateways: any[]) => {
  const executions = [];
  
  for (let i = 0; i < tasks.length; i++) {
    const gateway = gateways[i % gateways.length]; // Round-robin
    const execution = await executeViaGateway(token, gateway.id, tasks[i].id);
    executions.push({ task: tasks[i], gateway: gateway.name, execution });
  }
  
  return executions;
};

Environment Configuration

Docker Deployment

# .env
AUTH_MODE=local
LOCAL_AUTH_TOKEN=${LOCAL_AUTH_TOKEN}
BASE_URL=http://localhost:8000
NEXT_PUBLIC_API_URL=auto

# Database
DATABASE_URL=postgresql://postgres:postgres@db:5432/mission_control
REDIS_URL=redis://redis:6379

# Optional: Clerk authentication
# AUTH_MODE=clerk
# CLERK_PUBLISHABLE_KEY=${CLERK_PUBLISHABLE_KEY}
# CLERK_SECRET_KEY=${CLERK_SECRET_KEY}

Production Configuration

# .env
AUTH_MODE=clerk
BASE_URL=https://api.yourdomain.com
NEXT_PUBLIC_API_URL=https://api.yourdomain.com

# Database (managed PostgreSQL)
DATABASE_URL=${DATABASE_URL}
REDIS_URL=${REDIS_URL}

# Clerk
CLERK_PUBLISHABLE_KEY=${CLERK_PUBLISHABLE_KEY}
CLERK_SECRET_KEY=${CLERK_SECRET_KEY}

# Security
NODE_ENV=production
CORS_ORIGINS=https://app.yourdomain.com

Docker Commands

# Start services
docker compose -f compose.yml --env-file .env up -d --build

# Watch mode (auto-rebuild on changes)
docker compose -f compose.yml --env-file .env up --build --watch

# View logs
docker compose -f compose.yml --env-file .env logs -f

# Rebuild after pulling changes
docker compose -f compose.yml --env-file .env up -d --build --force-recreate

# Clean rebuild (no cache)
docker compose -f compose.yml --env-file .env build --no-cache --pull
docker compose -f compose.yml --env-file .env up -d --force-recreate

# Stop services
docker compose -f compose.yml --env-file .env down

# Stop and remove volumes
docker compose -f compose.yml --env-file .env down -v

Troubleshooting

Authentication Errors

Problem: 401 Unauthorized responses

# Verify token is set and long enough (50+ chars)
echo ${LOCAL_AUTH_TOKEN} | wc -c

# Check AUTH_MODE matches configuration
grep AUTH_MODE .env

# Test authentication
curl -H "Authorization: Bearer ${LOCAL_AUTH_TOKEN}" \
  http://localhost:8000/healthz

Database Connection Issues

Problem: Backend fails to connect to database

# Check database is running
docker compose -f compose.yml --env-file .env ps db

# Verify DATABASE_URL format
# Should be: postgresql://user:pass@host:port/dbname
grep DATABASE_URL .env

# Check database logs
docker compose -f compose.yml --env-file .env logs db

# Run migrations manually
docker compose -f compose.yml --env-file .env exec backend npm run db:migrate

Frontend Can't Reach API

Problem: API requests fail from frontend

# Check NEXT_PUBLIC_API_URL configuration
grep NEXT_PUBLIC_API_URL frontend/.env

# For auto mode, ensure BASE_URL is correct
grep BASE_URL .env

# Test API accessibility
curl http://localhost:8000/healthz

# Check CORS settings if using different origins
grep CORS_ORIGINS .env

Port Conflicts

Problem: Ports 3000 or 8000 already in use

# Find processes using ports
lsof -i :3000
lsof -i :8000

# Change ports in .env
# Backend: PORT=8001
# Frontend: edit docker-compose.yml or run locally on different port

Watch Mode Not Working

Problem: Docker Compose watch not detecting changes

# Verify Docker Compose version (requires 2.22.0+)
docker compose version

# Upgrade Docker Compose if needed
# Then restart with watch
docker compose -f compose.yml --env-file .env down
docker compose -f compose.yml --env-file .env up --build --watch

Gateway Connection Failures

Problem: Gateway registration or execution fails

# Verify gateway endpoint is accessible
curl -H "Authorization: Bearer ${GATEWAY_AUTH_TOKEN}" \
  https://gateway.example.com/healthz

# Check gateway configuration
curl -H "Authorization: Bearer ${LOCAL_AUTH_TOKEN}" \
  http://localhost:8000/api/gateways

# Review gateway logs in activity timeline
curl -H "Authorization: Bearer ${LOCAL_AUTH_TOKEN}" \
  "http://localhost:8000/api/activity?resource_type=gateway"

Reset Database

# Stop services
docker compose -f compose.yml --env-file .env down

# Remove database volume
docker volume rm openclaw-mission-control_postgres-data

# Restart and migrations will run automatically
docker compose -f compose.yml --env-file .env up -d --build

Testing

# Backend tests
cd backend
npm test

# Frontend tests
cd frontend
npm test

# E2E tests (if configured)
npm run test:e2e

Production Deployment

See docs/ for:

  • Production deployment guide
  • Security hardening checklist
  • Performance optimization
  • Monitoring and observability setup
  • Backup and disaster recovery

FAQ

What does the openclaw-mission-control skill do?

AI Agent Orchestration Dashboard for managing AI agents, tasks, and multi-agent collaboration via OpenClaw Gateway

How do I install openclaw-mission-control?

Run npx skills add https://github.com/reason-machines/hermes-skills --skill openclaw-mission-control in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/openclaw-mission-control/ (personal) or .claude/skills/openclaw-mission-control/ (project).

Which AI agents can use openclaw-mission-control?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is openclaw-mission-control safe to install?

No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.

Who maintains openclaw-mission-control?

It is published by reason-machines in reason-machines/hermes-skills. It has 174 recorded installs.

More from reason-machines/hermes-skills

View all →

hermes-agent-self-evolution

reason-machines/hermes-skills

Evolutionary self-improvement for Hermes Agent using DSPy + GEPA to optimize skills, prompts, and code

AI & Agents323 installs

hermes-webui-agent

reason-machines/hermes-skills

Expert in deploying, configuring, and using Hermes WebUI—a web interface for Hermes Agent with persistent memory, scheduled jobs, and multi-platform messaging.

267 installs

awesome-hermes-agent-ecosystem

reason-machines/hermes-skills

Open the skill to read its SKILL.md instructions.

232 installs

hermes-agent-framework

reason-machines/hermes-skills

Hermes Agent framework by Nous Research - self-improving AI agent with built-in learning loop, three-layer memory, and automatic skill evolution

AI & Agents222 installs

hermes-workspace-ai-agent-ui

reason-machines/hermes-skills

Native web workspace for Hermes Agent with chat, terminal, memory, skills, inspector, and multi-agent orchestration

AI & Agents218 installs

hermes-web-ui-dashboard

reason-machines/hermes-skills

Web dashboard for managing Hermes Agent multi-platform AI chat sessions, analytics, scheduled jobs, and platform channels

Data & Databases210 installs

Popular ai & agents skills

View category →

google-agents-cli-publish

google/agents-cli

This skill should be used when the user wants to "publish an agent", "publish my ADK agent", "register an agent with Gemini", "publish to Gemini" (formerly Gemini Enterprise), or needs guidance on the agents-cli publish gemini command. Also use when the user wants to "manage agents in Agent Registry", "list/update/delete registered agents", or "register an MCP server". Covers ADK vs A2A registration modes, programmatic and interactive usage, flag reference, auto-detection from deployment metadata, Agent Registry fleet management, and troubleshooting. Part of the agents-cli skills suite. Do NOT use for deployment (use google-agents-cli-deploy).

AI & Agents513.9K installs

google-agents-cli-eval

google/agents-cli

This skill should be used when the user wants to "run an evaluation", "evaluate my agent", "evaluate my ADK agent", "write an eval dataset", "analyze eval failures", "compare eval results", "optimize agent", or needs guidance on the Gemini platform eval methodology and the Quality Flywheel. Covers eval metrics, dataset schema, LLM-as-judge scoring, and common failure causes. Applies to any agents-cli project, whatever framework the agent is written in. Do NOT use for agent API code patterns (ADK: use google-agents-cli-adk-code), deployment (use google-agents-cli-deploy), or project scaffolding (use google-agents-cli-scaffold).

AI & Agents513.5K installs

skill-creator

anthropics/skills

Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.

OfficialAI & Agents416.4K installs

codex-pet

prime-skills/runcomfy-agent-skills

Codex Pet generator on RunComfy. Build a Codex-compatible Codex Pet spritesheet.webp + pet.json from a single reference image, drop it into ${CODEXHOME:-$HOME/.codex}/pets/ / and Codex picks it up as a custom Codex Pet next to the 8 built-ins. This skill produces the exact Codex Pet atlas Codex expects (1536x1872 PNG/WebP, 8 cols x 9 rows, 192x208 cells, 9 animation states — idle, running-right, running-left, waving, jumping, failed, waiting, running, review). Calls OpenAI GPT Image 2 edit ONCE via the local RunComfy CLI as runcomfy run openai/gpt-image-2/edit to produce a canonical Codex Pet pose, then assembles all 9 animation rows programmatically with ImageMagick micro-transforms — no Codex Pro, no $imagegen, no OPENAIAPIKEY required, only RUNCOMFYTOKEN. Triggers on "codex pet", "create codex pet", "make codex pet", "hatch codex pet", "/hatch image", "desktop pet codex", "codex pets", "spritesheet.webp", or any explicit ask to build a custom pet for OpenAI Codex.

AI & Agents402.1K installs

full-output-enforcement

leonxlnx/taste-skill

Overrides default LLM truncation behavior. Enforces complete code generation, bans placeholder patterns, and handles token-limit splits cleanly. Apply to any task requiring exhaustive, unabridged output.

AI & Agents401K installs

executing-plans

obra/superpowers

Use when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available

AI & Agents245.7K installs