Copilot Swarm Orchestrator

This is a submission for the GitHub Copilot CLI Challenge

Parallel, evidence-verified orchestration of real GitHub Copilot CLI sessions.

What I Built

Copilot Swarm Orchestrator (CSO) coordinates multiple GitHub Copilot CLI sessions across a dependency-aware plan.

Instead of running Copilot prompts one at a time and manually stitching the results together, this tool:

• Breaks goals into dependency-aware steps: Uses a local Planner to map out complex tasks.
• Runs independent steps in parallel waves: Executes multiple copilot -p sessions concurrently in-process using a custom Node.js execution loop.
• Executes each step as a real subprocess: Spawns the official copilot binary as a child process on its own isolated git branch.
• Captures and verifies results: Parses /share transcripts for concrete evidence (commands, test output, build output) to ensure work is verified before merging.
• Maintains a local audit trail: Writes all plans, execution logs, and proof artifacts to local folders (/plans, /runs, /proof) for total transparency.

Nothing is simulated. No undocumented flags. No cloud-based middleware.

It exists to make multi-area work like frontend, backend, tests, and integration faster without losing auditability.

Demo

Repository: https://github.com/moonrunnerkc/copilot-swarm-orchestrator

Quick demo command:

npm start demo todo-app

This runs four Copilot CLI sessions across three parallel waves and prints live, interleaved output so you can see concurrency in action.

Note: The demo is a real end-to-end run and typically takes ~12 to 18 minutes depending on model latency and install/test time.

Each run produces an auditable trail in the repo (plans/, runs/, proof/) showing:

• What each agent did (via captured /share transcripts)
• What evidence was verified (via per-step verification reports)
• What was merged

Screencast (fresh project interaction):

Screenshots (existing project interaction):

My Experience with GitHub Copilot CLI

This project was built with Copilot CLI, not "wrapped around" it.

I treated the Copilot CLI as a "Compute Engine" for intelligence. By spawning the binary as a child process, I was able to design sophisticated guardrails:

• Dependency Planning: Automating the order of operations.
• Bounded Agent Scopes: Ensuring agents stay in their lane.
• Transcript-Based Verification: Moving from "trusting the output" to "verifying the evidence."
• Per-Step Branch Isolation: Keeping the main codebase clean until work is proven.

Copilot accelerates implementation. The orchestrator adds structure, coordination, and evidence checks.

The result is a workflow where Copilot can move fast, fail safely, and leave behind proof instead of vibes.

Key Constraints (Intentional)

• Official Integration: Uses only documented Copilot CLI flags (such as -p, --model, --share).
• Zero Emulation: Does not embed or emulate Copilot; it uses your local authenticated CLI session.
• Evidence-Based: Does not guarantee correctness; verification is transcript-based (parsing commands and outputs), not just semantic guessing.
• Local Control: All execution is explicit, inspectable, and reversible (work happens on branches before merge).

Why It Matters

Copilot CLI is powerful for a single task. This project transforms it into a multi-step workforce. By adding orchestration, parallel execution, and a local audit trail, CSO moves the terminal from a "chat box" to a mission control center for complex, multi-agent development.

License: ISC

Built with: TypeScript, Node.js 18+, GitHub Copilot CLI