A document-driven agent orchestration system that takes software projects from idea through planning, execution, and review — built on native AI coding assistant primitives and a small set of simple Node.js scripts.
Agents communicate through structured markdown documents. Routing, triage, and state validation are handled by a single pipeline script (pipeline.js). No external services, no Docker, no npm install (unless you use the Dashboard UI).
Tell the Orchestrator your project idea, and it coordinates 12 specialized agents through a structured pipeline — research, requirements, design, architecture, planning, coding, and review — producing working software with full traceability from idea to implementation. It's automated spec-driven development!
flowchart TD
START([💡 Idea]) --> BRAINSTORM[Brainstorm]
BRAINSTORM --> |Goals| RESEARCH
subgraph PLANNING [Planning]
direction TB
RESEARCH[Researcher] --> |Research| PRD[Product Manager]
PRD --> |Requirements, Research| DESIGN[UX Designer]
DESIGN --> |Design, Requirements, Research| ARCH[Architect]
ARCH --> |Requirements, Architecture, Design, Research| MASTERPLAN[Create Master Plan]
end
MASTERPLAN --> GATE1(["✋ Human Approval"])
subgraph EXECUTION [Execution Loop]
direction TB
GATE1 --> PHASE[Plan Phase Tactical Planner]
PHASE --> HANDOFF[Plan Task]
HANDOFF --> |handoff| CODE[Code]
CODE --> |code|REVIEW[Code Review]
REVIEW -->|needs correction | HANDOFF
REVIEW -->|approved| COMMIT[🔀 Commit Code]
COMMIT --> MORETASKS{more tasks?}
MORETASKS -->|yes| HANDOFF
MORETASKS -->|no| PHASEREVIEW[Phase Review]
PHASEREVIEW -->|next phase| PHASE
PHASEREVIEW -->|needs correction| PHASE
end
PHASEREVIEW --> FINAL[Final Review]
FINAL --> GATE2(["✋ Human Approval"])
GATE2 --> DONE([✅ Complete])
The system includes a real-time monitoring dashboard — a Next.js web application that visualizes project state, pipeline progress, documents, and configuration.
Track active projects, drill into phase and task execution, read rendered planning documents, and view configuration — all updated in real time by reading the state.json file in each project. The project displayed in the screenshot was the project used to build the UI in 1-shot.
Learn more about the dashboard →
Twelve agents with strict separation of concerns. Each agent has a defined role, scoped tool access, and explicit write permissions. The Orchestrator is a thin skill-driven coordinator — it loads the orchestration skill, signals pipeline events, and routes via a compact action routing table. Never writes files directly. The Coder reads only its task handoff.
Documents are the inter-agent API. Every agent reads specific input documents, does its job, and writes its output document. There is no shared memory, no message passing, no runtime coupling between agents. Every interaction produces a traceable artifact.
CLI scripts, essentially a state machine, handles the mechanical decisions around that document exchange — routing, triage, and state validation — but agents themselves still communicate exclusively through structured markdown. The document-driven model is what makes the system portable and auditable.
Learn more about the pipeline →
Configurable critical human checkpoints are reliably enforced. Humans approve the Master Plan before any code is written and approve final results before completion. Execution gates are configurable: per-phase, per-task, or fully autonomous.
Pipeline routing, triage, and state validation are handled by a unified pipeline script (pipeline.js) — not LLM interpretation of prose. One event in, one deterministic action out. The script encodes external actions as a pure event-action lookup, internalizes triage decisions, and validates state invariants before every write. Same input always produces the same output.
Eighteen reusable skills bundle domain knowledge, templates, and instructions. Agents are composed with the skills they need — the system can be extended with new agents, capabilities, or adapted to new workflows by remixing skills.
A single orchestration.yml controls everything: project storage, pipeline limits, and human gate behavior. Sensible defaults out of the box, fully customizable.
Learn more about configuration →
Automatic git commits after each approved task. The Source Control Agent constructs conventional-format commit messages from task metadata and executes them — no manual git workflow needed. Configurable via orchestration.yml with auto_commit: always | ask | never (default ask, resolved at project start).
Learn more about source control →
Every task is reviewed against the plan. Code reviewers inspect source code directly. Minor issues trigger automatic corrective tasks. Critical issues halt the pipeline for human intervention. Plans don't drift unchecked. Pipeline failures are logged to a structured, append-only error log (ERROR-LOG.md) in each project folder.
| Page | Description |
|---|---|
| Getting Started | Installation, first project walkthrough, common commands |
| Guides | First-project walkthroughs, continuing projects, checking status |
| Pipeline | Planning and execution flow, human gates, error handling |
| Agents | All 12 agents — roles, access control, design constraints |
| Skills | All 18 skills and how they compose with agents |
| Templates | All 16 templates — purpose, producing agent, consuming agent |
| Configuration | orchestration.yml reference — all options explained |
| Source Control | Auto-commit configuration, agent modes, commit format, pipeline events |
| Project Structure | File layout, naming conventions, document types, state management |
| Monitoring Dashboard | Dashboard startup, features, data sources, real-time updates |
- Documents as interfaces — Agents never share memory. Every interaction is mediated by a structured markdown document.
- Sole writer policy — Every document type has exactly one agent that may write it.
- Self-contained handoffs — The Coder never reads external planning documents. Everything is inlined.
- Deterministic where possible — Routing, triage, and validation are pure functions. LLMs handle judgment work.
- Human in the loop — Critical gates are enforced. Humans approve plans and results.
- Continuous verification — Every task is reported and reviewed against the plan.
- Zero dependencies — Node.js built-ins only. No npm install.
Currently supported: GitHub Copilot (VS Code) — custom agents, skills, prompt files, instruction files, and agent mode.
The document-driven architecture is inherently portable. Agents communicate through markdown and YAML, not platform APIs. Adapting to other AI assistants primarily involves translating agent definitions to the target format.
Contributors working on this repo should enable the pre-commit hook so the
orchestration TypeScript stays type-clean before each commit. The hook file
is already committed at .githooks/pre-commit — point git at it once after
cloning:
git config core.hooksPath .githooks(Equivalent: node .claude/skills/orchestration/scripts/setup-hooks.js.)
This is dev-only setup. End users installing via the radorch installer
do not get the pre-commit hook configured.
See LICENSE for details.