A tool-agnostic agent orchestration system for AI-assisted development workflows. Copy it into any project and use it with Claude Code, GitHub Copilot, Cursor, Windsurf, Cline, or any other LLM coding assistant.
The system uses an Orchestrator agent that spawns specialised subagents to perform work in a structured workflow with two modes:
| Mode | Purpose |
|---|---|
| Plan Mode | Generate requirements, technical design, and task breakdown |
| Execute Mode | Implement tasks from approved specifications |
Every output — plan or code — passes through a Reviewer agent before being marked complete. Progress is tracked directly inside the spec files so it is always visible in version control.
Run install.sh from this repository to copy all agent files into your project:
# Copy into a project directory
./install.sh ../my-project
# Copy and overwrite any existing files
./install.sh ../my-project --overwriteWhat gets copied:
.claude/
├── agents/ — agent prompt definitions
├── templates/ — document templates
├── standards/ — coding, testing, and documentation standards
├── state/ — workflow state file
└── context-packets/ — directory for agent handoff packets (starts empty)
specs/
├── dependencies.yaml — global dependency graph (starts empty)
└── standalone-tasks/ — directory for tasks without a story/epic
After copying, fill in the placeholder standards files with the conventions for your project:
.claude/standards/code-standards.md
.claude/standards/testing-standards.md
.claude/standards/documentation-standards.md
repo/
├── install.sh # Copy this system to another project
├── specs/
│ ├── dependencies.yaml # Global dependency graph
│ ├── epic-XXX-name/
│ │ ├── epic.md # Epic definition + progress tracking
│ │ ├── stories/
│ │ │ └── story-XXX-name/
│ │ │ ├── story.md # Requirements + progress tracking
│ │ │ ├── design.md # Technical design
│ │ │ └── tasks.md # Task breakdown + progress tracking
│ │ └── increments/
│ │ └── increment-XXX.md # Working-code delivery definition
│ └── standalone-tasks/
│ └── task-XXX-name.md # Standalone task + progress tracking
│
└── .claude/
├── agents/ # Agent prompt definitions
│ ├── orchestrator.claude.md
│ ├── requirements-agent.claude.md
│ ├── design-agent.claude.md
│ ├── task-breakdown-agent.claude.md
│ ├── backend-executor.claude.md
│ ├── frontend-executor.claude.md
│ └── reviewer-agent.claude.md
├── templates/ # Document templates
│ ├── epic.md
│ ├── story.md
│ ├── design.md
│ ├── tasks.md
│ ├── increment.md
│ ├── standalone-task.md
│ └── context-packet.yaml
├── standards/ # Quality standards (fill these in)
│ ├── code-standards.md
│ ├── testing-standards.md
│ └── documentation-standards.md
├── context-packets/ # Agent handoff context (populated at runtime)
└── state/
└── workflow.yaml # Current workflow state
| Agent | Role | Mode |
|---|---|---|
| Orchestrator | Central coordinator — spawns subagents, tracks state, enforces quality gates | Both |
| Requirements Agent | Gathers and documents requirements into spec files | Plan |
| Design Agent | Creates technical designs from requirements | Plan |
| Task Breakdown Agent | Decomposes stories into atomic, dependency-ordered tasks | Plan |
| Backend Executor | Implements backend code, tests, and documentation | Execute |
| Frontend Executor | Implements frontend components, tests, and documentation | Execute |
| Reviewer Agent | Reviews all outputs; approves or rejects with actionable feedback | Both |
Start Plan Mode when you have a new goal but no spec files yet.
Give the Orchestrator agent the prompt from .claude/agents/orchestrator.claude.md and describe your goal. The orchestrator will:
- Spawn the Requirements Agent → produces
story.md/epic.md - Spawn the Design Agent → produces
design.md - Spawn the Task Breakdown Agent → produces
tasks.md - Spawn the Reviewer Agent → approves or rejects the plan
- Repeat reviewer loop until the plan is approved
Start Execute Mode when approved spec files already exist.
Give the Orchestrator agent the prompt from .claude/agents/orchestrator.claude.md and point it at the approved tasks.md. The orchestrator will:
- Pick the next unblocked task
- Spawn the appropriate Executor Agent (backend or frontend)
- Spawn the Reviewer Agent → approves or rejects the implementation
- Repeat reviewer loop until the task is approved
- Update progress tracking in the spec files
- Repeat from step 1 until all tasks are complete
All hierarchy combinations are supported:
Epic → Story → Task (full hierarchy)
Epic → Task (no stories)
Story → Task (no epic)
Task (standalone)
Progress is tracked directly inside the spec files. Every story.md, tasks.md, and epic.md contains live progress tables that are updated by the Orchestrator as work completes. This makes progress visible in every diff and in every code review.
Example — tasks.md after partial completion:
## Progress Summary
- Total: 4 tasks
- Complete: 2
- In Progress: 1
- Not Started: 1
- Blocked: 0
### Phase 1: Foundation
- [x] **T001**: Create user model
- Status: complete
- Completed: 2026-03-24 10:00
- Review: PASS (pkt-20260324-003)
- [x] **T002**: Create auth endpoints
- Status: complete
- Completed: 2026-03-24 11:30
- Review: PASS (pkt-20260324-005)
### Phase 2: Core
- [ ] **T003**: Create session middleware
- Status: in_progress
...Every agent handoff uses a context packet — a YAML file written to .claude/context-packets/. Context packets record what each agent was asked to do, what it decided, and what the reviewer concluded.
Context packets are named pkt-YYYYMMDD-NNN.yaml and follow the template at .claude/templates/context-packet.yaml:
id: pkt-20260324-007
from: backend-executor
to: reviewer-agent
created_at: 2026-03-24T12:00:00Z
task:
type: task
id: T003
name: Create session middleware
context:
inputs:
- path: specs/epic-001-auth/stories/story-001-login/design.md
purpose: follow the session design
outputs:
- path: src/middleware/session.py
purpose: session middleware implementation
decisions:
- Used Redis for session storage as specified in design
handoff_notes: |
All unit tests pass. See tests/middleware/test_session.py.
review:
decision: PASS
timestamp: 2026-03-24T12:30:00Z
blocking_issues: []
suggestions: []
notes: Implementation matches the design. Tests are thorough.specs/dependencies.yaml tracks dependencies at every level:
epics:
epic-001:
depends_on: []
blocks: [epic-002]
stories:
story-001:
depends_on: []
blocks: [story-002]
tasks:
T001:
depends_on: []
blocks: [T002, T003]
T002:
depends_on: [T001]
blocks: [T004]The Task Breakdown Agent populates task entries. The Orchestrator populates epic and story entries.
Every epic defines increments — working, user-verifiable code deliveries that follow an agile MVP approach. Increment definitions live at specs/epic-XXX-name/increments/increment-XXX.md and include a plain-language acceptance test the user can run themselves.
All agent prompts in .claude/agents/ are plain markdown with no tool-specific syntax. To use with any LLM assistant:
- Open a new conversation with your tool of choice.
- Paste the contents of the relevant agent prompt file as the system prompt or initial instruction.
- Provide the context packet (or describe the task) as the user message.
- The agent will follow the instructions in the prompt to produce its output.
Tested tools include Claude Code and GitHub Copilot. The prompts are designed to work with any capable LLM assistant.