Claude Code Operator Mission Control

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:

# 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

# 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:

# 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:

---
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

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:

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

git clone https://github.com/davidjelinekk/claude-code-operator-mission-control.git
cd claude-code-operator-mission-control
pnpm install

2. Configure environment

cp apps/api/.env.example apps/api/.env

Edit apps/api/.env:

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

# 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

pnpm dev
# API: http://localhost:3001
# Web: http://localhost:5173

5. Verify

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
• Source: davidjelinekk/claude-code-operator-mission-control
• License: MIT

Install and usage instructions live in the source repository linked above.