Minions Mission Control

The orchestrator that turns your coding CLIs into an autonomous engineering team.

Node.js 22.5+ Claude or Copilot Multi-Project Dashboard + CLI
Quick Start View on GitHub Learn Minions
🏗️
Ripley
Lead / Explorer
🔧
Dallas
Engineer
📊
Lambert
Analyst
🧠
Rebecca
Architect
⚙️
Ralph
Engineer

Autonomous Dispatch

Engine discovers work from plans, PRs, schedules, pipelines, and queues — then routes to the right agent by role, skill, and availability.

Plan Lifecycle

Plan → Approve → PRD → Execute → Review → Verify. Completed plans stay available until you manually archive them.

Team Meetings

Multi-agent meetings with investigate, debate, and conclude rounds. Agents research, discuss, and produce actionable conclusions.

Multi-Stage Pipelines

Chain tasks, meetings, plans, and more into automated workflows. Cron triggers or manual. Artifacts flow between stages.

Review / Fix Loop

After implementation, Minions can dispatch reviews, react to human PR comments, and send fixes back to the original author agent.

Git Worktree Isolation

Each agent works in its own worktree. No conflicts, no cross-contamination, safe parallel execution.

Knowledge Consolidation

Agent findings, quick notes, pinned notes, and feedback consolidate into team notes and a categorized knowledge base.

PR Integration

Tracks Azure DevOps and GitHub PRs, including review votes, build status, merge status, human comments, and context-only links.

Scheduled Tasks & Watches

Cron-style recurring work plus watches for PRs, work items, dispatches, meetings, pipelines, agents, and status changes.

Command Center & Doc Chat

Natural language orchestration, persistent CC tabs, document Q&A/editing, issue filing, routing updates, and local API actions.

Pluggable Runtimes

Run agents through Claude Code or GitHub Copilot CLI, with runtime-specific models, effort, session resume, and permission handling.

Live Dashboard

Real-time mission control on port 7331 with paginated views, optimistic updates, live streams, metrics, and settings.

One-Command Updates

minions update pulls the latest npm package, reapplies files, and restarts while preserving config and customizations.

Start here

Learn Minions

Get productive in one focused walkthrough, or follow the complete track from installation through day-to-day operations without leaving this page.

Open the full tutorials page ↗

Then see how Minions remembers what it learns ↓

Under the hood

How Minions Remembers

An interactive tour of the memory system: how findings are captured and consolidated, how the right evidence is retrieved for each dispatch, and how recalled text stays quoted evidence instead of a second instruction channel.

Open the full memory explainer ↗

1

Dashboard Overview

Home page with agent status cards, project bar, setup guidance, and engine state. All agents visible at a glance.

Dashboard overview with agent cards
Home page showing Minions Members, project bar, and engine status badge
2

Work Items

Paginated table with status, type, priority, agent, dependencies, artifacts, and linked PRs. PENDING DISPATCHED DONE FAILED. Retry, delete, archive, and add feedback with optimistic updates.

Work items table
Work items page — 20 per page with create, edit, retry, and delete actions
3

Plans & PRD

Plan cards with Approve / Discuss & Revise / Reject. PRD dependency graph with per-item retry, reopening, verification, and manual archive.

Plans and PRD progress
Plans page with status-colored cards, PRD dependency graph, and action buttons
4

Pull Requests

PR tracker sorted by date, with review, build, merge, conflict, and human-comment status. Linked to work items and PRD items. Manual PR linking and context-only observation supported.

Pull requests tracker
PRs sorted newest-first with build status, review status, and agent attribution
5

Team Meetings

Multi-agent meetings with 3 rounds: investigate, debate, conclude. Live progress per participant. Create plans from conclusions.

Meetings page
Meetings with round status badges, participant progress, and archive/delete actions
6

Pipelines

Multi-stage workflows chaining tasks, meetings, plans, tests, docs, and more. Cron triggers or manual runs. Artifact tracking between stages.

Pipelines page
Pipeline cards with stage flow visualization, run history, and progress bars
7

Notes & Knowledge Base

Inbox for agent findings, quick notes, pinned notes, consolidated team notes, and categorized knowledge base. Inline Q&A/editing on documents.

Notes and knowledge base
Notes inbox, team notes, and knowledge base with category tabs and pagination
8

Scheduled Tasks

Cron-style recurring work with a visual builder. Schedule work items, tests, docs, plans, asks, meetings, and recurring maintenance.

Schedules page
Schedule list with cron expressions, last-run times, and enable/disable toggles
9

Engine & Metrics

Dispatch queue, engine log, agent metrics, token usage, runtime/model data, quality signals, and context pressure. All paginated.

Engine page
Active/pending dispatches, completed history, engine log, and per-agent quality metrics
10

Command Center

Natural language delegation. CC orchestrates — agents implement. Sessions persist across refreshes and tabs; actions can create work, notes, plans, watches, PR links, and issues.

Command Center panel
Command Center side panel with conversation history, action execution, and session indicator

Quick Start

Prerequisites: Node.js 22.5+, Git, Azure CLI, and at least one agent runtime — install Claude Code or GitHub Copilot CLI separately. Nothing needs to be cloned: the installer pulls @opg-microsoft/minions straight from the ISS ProjectFeed-ISS Azure Artifacts feed.

Download the installer for your platform

Two ways to run the same install — pick the one that matches your machine.

Running the downloaded installer is the whole install — there is no separate sign-in step. It reuses an Azure CLI session you already have without prompting; if you have none it signs you in once itself with az login --allow-no-subscriptions, then retries the token exactly once. A headless or automated run never hangs on a prompt: it stops immediately and prints that command for you to run in a real terminal. The short-lived Azure DevOps token it gets is used only in a throwaway npm config it deletes on exit, and it never creates or stores a PAT. It verifies feed read access before it changes anything on your machine, then stages the verified version of @opg-microsoft/minions into that same throwaway folder and hands the rest to the canonical installer that ships inside the package. Nothing is installed globally until that installer owns the order: it backs up your state, removes any earlier public-npm install before installing the internal one, then runs minions init and a health-verified restart. It is idempotent: re-run it any time to upgrade.

Both installers install the newest published version by default. To go back to a known-good older build, pin an exact version — -Version 1.2.3 on Windows, --version 1.2.3 on macOS or Linux, or MINIONS_INSTALL_VERSION=1.2.3 in the environment, with the flag winning over the environment. A pin that is not an exact published version is rejected before the installer requests a token, creates its staging folder, or downloads anything, and the pinned version is the one that is staged and handed to the canonical installer — the two can never split. Each run also prints its launcher revision as its first line (==> Minions launcher install-minions.ps1 sha256:…); quote that line in a bug report so a stale copy sitting in your downloads folder is obvious.

After the installer finishes

# Bootstrap ~/.minions/ and scan/link repositories
minions init

# Or add a specific project later
minions add ~/my-project

# Start engine + dashboard, then open http://localhost:7331
minions restart --open
minions dash

# Give your first task
minions work "Explore the codebase and document the architecture"

# Useful operations
minions status
minions doctor
minions config set-cli copilot --model gpt-5.4

# Update to latest
minions update

Minions is published as @opg-microsoft/minions to the internal ProjectFeed-ISS Azure Artifacts feed — it is not published to public npm. Installing needs an Azure identity and Azure Artifacts read permission on ProjectFeed-ISS, because the feed is private to the organization. You do not run az login yourself: the installer uses the Azure CLI session you already have, and signs you in once with az login --allow-no-subscriptions only if there is none. If your identity is signed in but not authorized, it says so instead of sending you back through a sign-in that cannot help. The installer's npm view check then proves feed access before anything on your machine changes, so a missing permission fails safely; request feed access from the ISS feed owners and re-run.

Architecture

  +-----------------------------------------------------+
  |                  ~/.minions/ (central hub)          |
  |                                                     |
  |   engine.js ---- 60s tick loop ----+                |
  |       |                            |                |
  |   discover work    spawn agents    poll PRs/comments|
  |       |                |              |             |
  |   +-------+    +-------------+   +--------+         |
  |   | Plans |    |  Worktrees  |   | ADO /  |         |
  |   | PRDs  |    |  isolated   |   | GitHub |         |
  |   | Items |    |  per agent  |   +--------+         |
  |   +-------+    +-------------+                      |
  |                                                     |
  |   dashboard.js -- port 7331 -- mission control      |
  |   runtimes/ -- Claude Code or GitHub Copilot CLI    |
  |   meetings/ -- multi-agent discussions              |
  |   pipelines/ -- multi-stage workflows               |
  |   schedules + watches -- recurring/conditional work |
  |   notes.md + knowledge/ -- team memory and KB       |
  +-----------------------------------------------------+