# Claude Code Operator Mission Control > Workflow orchestration dashboard for Claude Code — manage agents, skills, sessions, and projects - **Type:** MCP server - **Install:** `agentstack add mcp-davidjelinekk-claude-code-operator-mission-control` - **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior - **Seller:** [davidjelinekk](https://agentstack.voostack.com/s/davidjelinekk) - **Installs:** 0 - **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml) - **Latest version:** 0.1.0 - **License:** MIT - **Upstream author:** [davidjelinekk](https://github.com/davidjelinekk) - **Source:** https://github.com/davidjelinekk/claude-code-operator-mission-control ## Install ```sh agentstack add mcp-davidjelinekk-claude-code-operator-mission-control ``` Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent. ## About The operating system for your Claude Code agent fleet. --- ``` > cc_operator.init() [orchestration] spawn, stream, manage Agent SDK sessions [context-graph] intent-aware RAG with self-growing knowledge graph [cli-scripts] bash/python/node → MCP tools, zero glue code [governance] atomic task claims, approval workflows, board policies [message-bus] inter-agent messaging + live flow visualization [analytics] token usage, session archives, cost tracking status: operational ``` --- ## Not a Plugin. A Platform. Claude Code Operator is **not** a Claude Code plugin, extension, or wrapper. It is an **orchestration platform** that sits above Claude Code and manages entire agent fleets. ``` ┌─────────────────────────────────────────────┐ │ Claude Code Operator (Platform) │ │ │ │ ┌───────────┐ ┌────────┐ ┌──────────┐ │ │ │ Dashboard │ │REST API│ │ Workers │ │ │ │ React 19 │ │ Hono │ │ 6 bg │ │ │ └───────────┘ └───┬────┘ └──────────┘ │ │ │ │ │ ┌──────────────────┴──────────────────┐ │ │ │ PostgreSQL + pgvector Redis │ │ │ │ 37 tables 768-dim pub/sub │ │ │ └──────────────────┬──────────────────┘ │ │ │ │ │ spawns & governs many: │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │Session 1 │ │Session 2 │ │Session N │ │ │ │ Claude │ │ Claude │ │ Claude │ │ │ └──────────┘ └──────────┘ └──────────┘ │ │ ↑ injected: governance, context, │ │ sandbox, MCP tools, message bus │ └─────────────────────────────────────────────┘ ``` A **plugin** lives inside a single Claude Code session. CC Operator lives *above* — it spawns sessions, injects governance, builds knowledge across sessions, and gives you a control plane. | | Plugin | CC Operator | |---|--------|-------------| | **Scope** | Single session | Fleet of sessions | | **State** | Filesystem only | PostgreSQL + Redis + pgvector | | **UI** | None | Full React dashboard | | **Knowledge** | Per-session | Cross-session knowledge graph that grows itself | | **Governance** | None | Approval workflows, board policies, tool-level interception | | **Analytics** | None | Token usage, cost tracking, session archives | | **Communication** | None | Inter-agent message bus + flow visualization | Every spawned agent session gets CC Operator capabilities injected automatically: ``` cc_operator.spawn("Fix the auth bug", { boardId, agent: "debugger" }) │ ├─→ canUseTool() tool governance — logs use, blocks risky ops ├─→ systemPrompt context graph knowledge injected by intent ├─→ mcpServers agent bus + claude-mem + script tools ├─→ sandbox isolated filesystem/network execution └─→ on completion extract knowledge → compress → archive ``` The analogy: **Kubernetes is to containers what Claude Code Operator is to Claude Code sessions.** --- ## How It Works You set up a board. The orchestration agent runs it. Worker agents do the work. ``` You: "Create a board for Q2 marketing with tasks for competitor research, content calendar, and ad creative. Research must finish before content calendar starts." Claude (via MCP): → creates board, 3 tasks, dependency chain You: "Run it." Orchestration Agent: → Checks queue: only "competitor research" is unblocked → Claims task, spawns worker agent with governance + context → Worker reads files, analyzes data, completes task → Marks done → "content calendar" now unblocked → Claims next task, spawns worker... → Continues until queue empty "Board complete. 3/3 tasks done. Total cost: $0.47. Ad creative pending your approval." ``` **Two layers:** | Layer | What it does | |-------|-------------| | **Orchestration Agent** | Autonomous runner that uses the CLI to process boards | | **Platform** | API + Dashboard + Boards + Governance + Knowledge + Analytics | Claude Code handles execution (tools, channels, streaming). The Operator handles orchestration (what runs, when, governed how, tracked at what cost). --- ## Orchestration Agent The `operator-runner` agent autonomously processes board task queues using the `cc-operator` CLI: ```bash # Install (or run cc-operator init) cp agents/operator-runner.md ~/.claude/agents/ npm install -g cc-operator cc-operator init # configure URL + token # Run a board claude --agent operator-runner --prompt "Process all tasks on board " ``` The agent uses CLI commands to: 1. Check board status: `cc-operator board summary --json` 2. Find unblocked tasks and claim the highest-priority one 3. Spawn a governed worker: `cc-operator spawn "do the work" --board --task --stream` 4. Monitor until completion 5. Mark task done, check what's now unblocked 6. Repeat until queue empty or budget reached 7. Report: tasks done, cost, pending approvals No MCP configuration. No settings files. Just the CLI. --- ## Why This Exists Claude Code Operator is an **operating system for running AI agent teams** — with persistent state, self-growing knowledge, governance policies, and a dashboard. It's the difference between ad-hoc AI usage and managed AI operations. Every Claude Code user already has agents, skills, scripts, and session logs in `~/.claude/`. Claude Code Operator reads all of it and gives you an operator console on top. No SDK to learn. Your agents are markdown files. Your tools are bash scripts with a manifest. Everything you already have becomes orchestratable. --- ## What Makes It Different ### The RAG isn't search — it's intent-aware context injection Most RAG systems do: query → embed → top-K → stuff into prompt. Claude Code Operator classifies the **intent** of each agent spawn (debugging? planning? reviewing?) and dynamically reweights five retrieval sources: ``` agent.spawn(prompt, { boardId }) │ ▼ intent.classify(prompt) │ ├── vector similarity (pgvector, 768-dim) ├── graph neighborhood (1-hop entities + observations) ├── board memory (recent, with time decay) ├── session archives (compressed prior sessions) └── error patterns (known failure modes) │ ▼ rerank(top_10, via: claude-haiku) │ ▼ block injected into agent system prompt ``` The context an agent gets is shaped by *what it's trying to do*, not just what's textually similar. ### The knowledge graph grows itself Every activity event gets processed by an extraction worker (Claude Haiku) that pulls entities, relationships, and observations. Deduplication happens via vector similarity — not content hashing: | Similarity | Action | |-----------|--------| | > 0.85 | Skip (near-duplicate) | | 0.7 – 0.85 | Replace if new observation is richer | | ### CLI scripts become MCP tools with zero glue code Write a bash/python/node script. Add a `SCRIPT.md` with YAML frontmatter. It's now an MCP tool any agent session can call. ``` ~/.claude/scripts/my-tool/ SCRIPT.md ← name, description, args-schema, interpreter my_tool.py ← the executable ``` The system infers the interpreter from the file extension, routes input three ways (CLI args, stdin JSON, or env vars), enforces timeouts with SIGTERM → SIGKILL escalation, and validates inputs against your JSON Schema. No server to run. No SDK to integrate. ### Real governance, not just chat - **Tool-level interception** — every tool call in governed sessions passes through `canUseTool` — logs all tool usage, blocks destructive operations (`rm -rf`, force-push, writes to `.env`/`.key`), auto-creates approval records for human review - **Atomic task claiming** — race-free `UPDATE...WHERE status='inbox' RETURNING` prevents double-assignment - **Circular dependency detection** — recursive CTE with depth limit when adding task deps - **Board-level policies** — block status changes with pending approvals, require review before done, restrict who can change status - **Approval workflows** — confidence-scored approvals with SSE streaming; resolution triggers gateway agent sessions reactively - **Sandbox isolation** — spawned agents run with `sandbox: { enabled: true }` for restricted filesystem/network access ### Flow visualization shows relationships that don't exist yet Beyond explicit agent-to-agent messages, the system synthesizes **implicit dispatch edges** — when a task transitions to `in_progress`, a synthetic edge appears from the gateway agent. You see both what agents are *telling each other* and the task topology that *connects them*. ``` ┌──────────┐ ┌──────────┐ │ planner │──message──│ debugger │ └────┬─────┘ └──────────┘ │ dispatched (synthetic) ▼ ┌──────────┐ │ executor │ └──────────┘ ``` --- ## Packages | Package | Purpose | |---------|---------| | `cc-operator` | **CLI** — primary interface for managing boards, tasks, agents | | `@cc-operator/sdk` | TypeScript API client (19 resource classes, SSE streaming) | | `create-cc-operator` | Scaffolding — `npx create-cc-operator my-project` | ### Quick Install ```bash # Scaffold a new project (fastest) npx create-cc-operator my-project # Or install individually npm install @cc-operator/sdk # TypeScript API client npm install -g cc-operator # Global CLI ``` ### CLI — `cc-operator` ``` cc-operator init # Configure + install orchestration agent cc-operator status # Health check cc-operator board list # List boards cc-operator spawn "Fix the bug" --agent=debugger --stream cc-operator spawn "Refactor auth" --provider codex --model o4-mini --stream cc-operator spawn "Add tests" --provider gemini --model gemini-2.5-pro --stream ``` ### Multi-Provider Orchestration Spawn sessions with Claude Code (default), OpenAI Codex CLI, or Google Gemini CLI: ```bash # Via CLI cc-operator spawn "analyze the data" --provider gemini --stream # Via API curl -X POST http://localhost:3001/api/agent-sdk/spawn \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"prompt":"fix the bug","provider":"codex","model":"o4-mini"}' # Check available providers curl http://localhost:3001/api/agent-sdk/providers \ -H "Authorization: Bearer $TOKEN" ``` Agents can be configured with a default provider in their `.md` frontmatter: ```yaml --- name: codex-worker provider: codex model: o4-mini --- ``` Set `OPENAI_API_KEY` and/or `GOOGLE_API_KEY` in your `.env` to enable non-Claude providers. --- ## Quick Start ```bash git clone https://github.com/davidjelinekk/claude-code-operator-mission-control.git cd claude-code-operator-mission-control pnpm install # Start PostgreSQL + Redis via Docker docker compose up -d # Configure cp apps/api/.env.example apps/api/.env # Edit .env — set OPERATOR_TOKEN, AUTH_USER, AUTH_PASS # DATABASE_URL=postgresql://operator:operator@localhost:5434/cc_operator # Migrate and run cd apps/api && pnpm db:migrate && cd ../.. pnpm dev # API → http://localhost:3001 Web → http://localhost:5173 ``` > **No Docker?** See [Homebrew setup](#homebrew-setup) below. --- ## Capabilities ``` > cc_operator.capabilities() orchestration spawn/stream/manage Agent SDK sessions boards kanban task management with agent assignment agents discover + manage from ~/.claude/agents/*.md skills browse skills, MCP servers, CLI scripts context-graph intent-aware RAG with self-growing knowledge graph message-bus inter-agent direct + broadcast messaging flow real-time agent communication graph approvals confidence-scored governance workflows projects multi-task orchestration (sequential/parallel) analytics token usage + cost tracking from JSONL logs events websocket + SSE + redis pub/sub + webhooks ``` ## Architecture ``` apps/ api/ Hono API server (Node 22+, PostgreSQL, Redis) web/ React 19 SPA (TanStack Router/Query, Tailwind, Vite) packages/ shared-types/ Zod schemas shared between API and web tsconfig/ Shared TypeScript configs ``` ## Tech Stack | Layer | Tech | |-------|------| | API | Node.js 22, Hono, Drizzle ORM, PostgreSQL + pgvector, Redis, WebSockets | | RAG | Ollama (nomic-embed-text), pgvector, Claude Haiku (extraction + reranking + session compression) | | Web | React 19, TanStack Router, Tailwind CSS, Vite | | SDK | `@anthropic-ai/claude-agent-sdk` for session orchestration | | Shared | Zod schemas (`@claude-code-operator/shared-types`) | | Monorepo | pnpm workspaces + Turborepo | --- ## Setup ### Prerequisites - **Node.js 22+** — `node --version` - **pnpm 10+** — `pnpm --version` - **PostgreSQL 17** — via [Docker](#quick-start) or [Homebrew](#homebrew-setup) - **Redis** — via [Docker](#quick-start) or [Homebrew](#homebrew-setup) - **Claude CLI** (optional) — for orchestration: `npm install -g @anthropic-ai/claude-code` - **Ollama** (optional) — for semantic search: `brew install ollama` ### Homebrew Setup If you prefer native installs over Docker: ```bash brew install node pnpm postgresql@17 redis brew services start postgresql@17 brew services start redis # Optional: semantic search brew install ollama pgvector ollama pull nomic-embed-text ollama serve ``` ### 1. Clone and install ```bash git clone https://github.com/davidjelinekk/claude-code-operator-mission-control.git cd claude-code-operator-mission-control pnpm install ``` ### 2. Configure environment ```bash cp apps/api/.env.example apps/api/.env ``` Edit `apps/api/.env`: ```bash OPERATOR_TOKEN=$(openssl rand -hex 32) AUTH_USER=admin AUTH_PASS= # Docker setup DATABASE_URL=postgresql://operator:operator@localhost:5434/cc_operator REDIS_URL=redis://127.0.0.1:6379/2 # Or Homebrew setup # DATABASE_URL=postgresql://localhost:5432/cc_operator ``` ### 3. Database ```bash # If using Homebrew PostgreSQL (Docker auto-creates the database) createdb cc_operator # Run Drizzle migrations cd apps/api && pnpm db:migrate && cd ../.. # Optional: pgvector + context graph + agent messaging psql $DATABASE_URL -f apps/api/src/db/migrations/9001_pgvector_embeddings.sql psql $DATABASE_URL -f apps/api/src/db/migrations/9002_context_graph.sql psql $DATABASE_URL -f apps/api/src/db/migrations/9003_session_archives.sql psql $DATABASE_URL -f apps/api/src/db/migrations/9004_agent_messages.sql ``` ### 4. Run ```bash pnpm dev # API: http://localhost:3001 # Web: http://localhost:5173 ``` ### 5. Verify ```bash curl http://localhost:3001/health # → { "status": "ok", ... } ``` ### 6. First login Open http://localhost:5173. Log in with the `AUTH_USER` / `AUTH_PASS` credentials from your `.env`. These seed the initial admin account on first startup. ### Orchestration (optional) To spawn Agent SDK sessions from the dashboard: 1. Install Claude Code CLI: `npm install -g @anthropic-ai/claude-code` 2. Add `ANTHROPIC_API_KEY` to `apps/api/.env` 3. Ensure `~/.claude/` exists (run `claude` once to bootstrap, or `mkdir -p ~/.claude/{agents,skills,scripts}`) --- ## Dashboard Pages | Route | Description | |-------|-------------| | `/` | Home dashboard | | `/boards` | Kanban boards with task management | | `/agents` | Agent discovery and management | | `/o … ## Source & license This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code. - **Author:** [davidjelinekk](https://github.com/davidjelinekk) - **Source:** [davidjelinekk/claude-code-operator-mission-control](https://github.com/davidjelinekk/claude-code-operator-mission-control) - **License:** MIT Install and usage instructions live in the source repository linked above. ## Pricing - **Free** — Free ## Security capabilities Automated source analysis of v0.1.0 — what this tool can access: - **Network access:** yes - **Filesystem access:** no - **Shell / process execution:** yes - **Environment & secrets:** yes - **Dynamic code execution:** no *"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.* ## Versions - **0.1.0** — security scan: passed — Imported from the upstream source. ## Links - Listing page: https://agentstack.voostack.com/l/mcp-davidjelinekk-claude-code-operator-mission-control - Seller: https://agentstack.voostack.com/s/davidjelinekk - Browse the marketplace: https://agentstack.voostack.com/browse --- Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.