orchestrator

Disclaimer: Claude Orchestrator is an independent, community-developed open-source project. It is not affiliated with, endorsed by, or officially associated with Anthropic, PBC or any of its products (including Claude, Claude Code, or the Claude API). "Claude" and "Anthropic" are trademarks of Anthropic, PBC. This project is a third-party plugin built by the community to extend Claude Code functionality.

---

Claude Orchestrator

Autonomous Development System for Claude Code

Transform ideas into production-ready applications with zero manual intervention.

Spec → Plan → Tasks → 100% Working App

Installation

# Add the marketplace
/plugin marketplace add devsforge/orchestrator

# Install the plugin
/plugin install orchestrator@devsforge-orchestrator

Features

• Multi-Agent Orchestration - 12+ specialized agents working in coordination
• Autonomous Development Loop - Tasks executed automatically with quality gates
• Self-Healing - Automatic error detection and recovery (up to 3 retries)
• Quality Gates - Automated checks at every stage (TypeScript, ESLint, tests)
• State Persistence - Resume development from any checkpoint
• Parallel Execution - Independent tasks run concurrently

Quick Start

1. Start a New Project

/orchestrator:start

Follow the prompts to describe your project idea. The orchestrator will:

• Generate a detailed specification
• Design the system architecture
• Create atomic, executable tasks

2. Begin Autonomous Development

/orchestrator:continue

The orchestrator will automatically:

• Pick the next task based on dependencies
• Delegate to the appropriate specialized agent
• Verify completion with quality gates
• Handle errors with self-healing
• Create checkpoints for progress tracking

3. Monitor Progress

/orchestrator:status

View:

• Current phase and progress percentage
• Running and blocked tasks
• Recent activity
• Checkpoints

Commands

Command	Description
/orchestrator:start	Initialize a new project from an idea
/orchestrator:continue	Run autonomous development loop
/orchestrator:status	Show progress dashboard
/orchestrator:tasks	List all tasks with status
/orchestrator:pause	Pause after current task
/orchestrator:resume	Resume paused session
/orchestrator:rollback <CP>	Rollback to checkpoint
/orchestrator:help	Show documentation

Architecture

┌─────────────────────────────────────────────────────────────┐
│                    ORCHESTRATOR CORE                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  COMMANDS (/orchestrator:*)                                         │
│  └── start, continue, status, tasks, pause, rollback        │
│                                                             │
│  BRAIN (Orchestrator Agent)                                 │
│  ├── State Machine (6 phases)                               │
│  ├── Decision Engine                                        │
│  ├── Error Recovery (3 retries)                             │
│  └── Quality Gates                                          │
│                                                             │
│  AGENT POOLS                                                │
│  ├── PLANNING: spec-writer, architect, task-planner         │
│  ├── EXECUTION: frontend-dev, backend-dev, database-expert  │
│  └── QUALITY: test-engineer, code-reviewer, security-auditor│
│                                                             │
│  SKILLS LIBRARY                                             │
│  └── project-planning, error-recovery, frontend-patterns... │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Development Lifecycle

IDEATION → SPECIFICATION → ARCHITECTURE → PLANNING → IMPLEMENTATION → TESTING → DEPLOYMENT

Phase 1: Ideation → Specification

• User describes their idea
• spec-writer agent creates detailed requirements
• Output: specification.md

Phase 2: Specification → Architecture

• architect agent designs the system
• Tech stack selection with rationale (ADRs)
• Output: architecture.md

Phase 3: Architecture → Planning

• task-planner agent breaks down work
• Atomic tasks (15-20 min each)
• Dependencies mapped
• Output: tasks.json

Phase 4: Implementation (Autonomous Loop)

PICK TASK → DELEGATE → EXECUTE → VERIFY → COMMIT
    ↑                                    │
    └────────────────────────────────────┘

Phase 5: Testing

• Integration tests
• E2E tests
• Security audit
• Performance analysis

Phase 6: Deployment

• Build optimization
• Containerization
• CI/CD setup
• Production deployment

Specialized Agents