OrchFlow's core orchestration engine is built in Rust for performance and reliability:

Transport-agnostic orchestration engine for managing terminal sessions, panes, and plugins with an event-driven architecture.

Features:

• Manager pattern for coordinating operations
• State management with persistent storage
• Plugin system with event-driven architecture
• Backend abstraction for terminal multiplexers
• Async/await support throughout

Terminal multiplexer abstraction layer supporting tmux, mock backends, and custom implementations.

Features:

• Clean trait-based interface for terminal multiplexers
• Production: Full tmux integration with session and pane management
• Testing: Mock backend with configurable behavior for testing and development
• Factory pattern for automatic backend selection
• Comprehensive error handling

High-performance terminal I/O management with PTY support, buffering, and stream processing.

Features:

• Production: Real PTY creation and lifecycle management for actual terminal processes
• Async streams for non-blocking terminal operations
• Smart buffering with ring buffer and scrollback
• Stream processing and output management
• Resource cleanup with automatic Drop implementation
• Testing: Use MockBackend from orchflow-mux for testing without real PTYs

Application Layer
├── Your Application Code
└── OrchFlow Integration
    │
OrchFlow Core
├── Manager · State · Events · Plugins
├── Backend Abstraction
└── OrchFlow Mux
    ├── Tmux Backend
    ├── Mock Backend (testing)
    └── Custom Backends
        │
OrchFlow Terminal
├── PTY Management
├── I/O Streaming
└── Buffer Management

• orchflow-core README - Core orchestration engine
• orchflow-mux README - Terminal multiplexer abstraction
• orchflow-terminal README - Terminal I/O management

⚠️ This portion of the project is under development ⚠️

Natural language orchestration for command-line workflows.

OrchFlow transforms how you work with AI by injecting orchestration capabilities directly into Claude. Instead of managing multiple windows or sessions, you naturally orchestrate complex tasks through conversation - Claude becomes capable of working on multiple aspects of your project simultaneously.

# Install OrchFlow
npm install -g @orchflow/claude-flow

# Launch Claude with orchestration powers
orchflow

Now in your Claude conversation:

You: Let's build a complete authentication system - we need the API, 
     frontend components, and comprehensive tests

Claude: I'll help you build a complete authentication system. This is 
        perfect for parallel development. Let me organize our work:
        
        ✓ API Developer - Building authentication endpoints
        ✓ Frontend Developer - Creating login/signup components
        ✓ Test Engineer - Writing comprehensive test suite
        
        Starting with the API, we'll use JWT tokens for authentication...
        [Claude naturally orchestrates while maintaining conversation flow]

Claude understands when to parallelize work and orchestrates naturally:

• Automatically creates workers when you describe multiple tasks
• Seamlessly switches context when you ask about different components
• Shares knowledge and decisions across all work streams
• Maintains conversation flow while managing complex orchestration

No special commands or syntax needed:

• Just describe what you want to build
• Ask about progress on any component
• Request changes that apply across all workers
• Claude handles the orchestration invisibly

OrchFlow feels like a natural extension of Claude:

• Works within your normal Claude conversation
• Context switching happens automatically
• Knowledge sharing occurs behind the scenes
• Session state persists across conversations

• Node.js 16+
• claude-flow 2.0.0-alpha.50+
• tmux (automatically installed if missing)
• macOS, Linux, or Windows (WSL)

# Install claude-flow first
npm install -g claude-flow@2.0.0-alpha.50

# Clone and build OrchFlow
git clone https://github.com/orchflow/orchflow.git
cd orchflow/packages/orchflow-claude-flow
npm install
npm run build
npm install -g .

# Launch (tmux will be automatically installed if missing)
orchflow

# Install claude-flow first
npm install -g claude-flow@2.0.0-alpha.50

# Install OrchFlow (when published)
npm install -g @orchflow/claude-flow

# Launch
orchflow

• Automatic tmux setup: No manual tmux installation required
• Fallback support: Gracefully falls back to inline mode if tmux unavailable
• Cross-platform: Supports 9 different package managers for tmux installation
• Configuration management: Automatic tmux configuration with optimal settings

Once OrchFlow launches, you'll see an interactive setup wizard:

🎯 Setup Options
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📱 VS Code Environment Detected

How would you like to use OrchFlow?

1. 🖥️  Split Terminal (tmux) - Full featured with live status pane
2. 📄 Inline Mode - Status updates in main terminal
3. 📊 VS Code Status Bar - Minimal updates in bottom bar
4. 🪟 Separate Window - Dedicated VS Code window for status

After setup, use natural language in Claude:

# Development tasks
Build a complete authentication system with React frontend and Node.js backend
Create comprehensive testing suite with unit and integration tests
Develop REST API with authentication and database integration
Set up CI/CD pipeline with automated testing and deployment

# Progress inquiries
How's the frontend development coming along?
Show me the status of all workers
What's the current system performance?

# Session management
Save session as "auth-system-project"
Restore session "auth-system-project"

# Create coordinated workers for full-stack development
Build backend API with Express and PostgreSQL
Create React frontend with TypeScript
Set up authentication with JWT tokens
Deploy application to AWS

# Monitor all workers
Show me all workers
Display progress for each worker

# Automated code review workflow
Review pull request #123 for security issues
Check test coverage for authentication module
Validate API documentation completeness
Run performance benchmarks on endpoints

# Technology research
Research React vs Vue vs Angular for enterprise
Investigate microservices patterns
Analyze OAuth 2.0 implementation strategies
Study Kubernetes orchestration concepts

• Quick Start Guide - 5-minute setup with auto-installation
• Architecture Overview - Unified architecture deep dive
• Examples - Common workflows and patterns

• API Documentation - Programmatic usage
• CLI Reference - Command-line options
• Integration Guide - MCP integration patterns
• Troubleshooting - Problem resolution

• Implementation Status - Technical implementation details
• Deployment Guide - Production deployment
• Documentation Index - All documentation

OrchFlow features a unified architecture built for production-ready orchestration with comprehensive type safety and streamlined component integration:

User Input (Natural Language)
    ↓
OrchFlow Terminal Interface
    ├── UnifiedSetupOrchestrator (automatic tmux setup)
    ├── Enhanced MCP Tools (7 specialized tools)
    ├── Unified Manager System (5 core managers)
    └── Status Monitoring & Real-time Updates
         ↓
    claude-flow (all commands preserved)
         ↓
    Terminal Multiplexer (tmux with auto-install)

• UnifiedSetupOrchestrator: Single orchestrator handling all setup flows with automatic tmux installation
• 5 Core Managers: ConfigurationManager, ContextManager, TerminalManager, WorkerManager, UIManager
• Enhanced MCP Tools: 7 specialized tools for Claude integration with proper type safety
• Unified Interfaces: Single source of truth for all type definitions in unified-interfaces.ts
• Auto-Installation: Automatic tmux setup with fallback to inline mode
• Type Safety: 100% TypeScript compliance with no production 'as any' casts

import { orchestrate, createWorker, getStatus } from '@orchflow/claude-flow';

// Create a task programmatically
const worker = await createWorker({
  task: "Build authentication system",
  type: "developer"
});

// Monitor progress
const status = await getStatus(worker.id);
console.log(`Progress: ${status.progress}%`);

// Connect to worker
await connectToWorker(worker.id);

• Startup Time: < 2 seconds (improved with unified architecture)
• Memory Overhead: < 80MB for orchestration (reduced through consolidation)
• Worker Capacity: 8 concurrent workers (configurable)
• Response Time: Real-time orchestration via Claude
• TypeScript Codebase: 785KB optimized CLI bundle, 782KB library bundle
• Build Time: < 3 seconds for complete compilation
• Type Safety: 100% TypeScript compliance with zero production 'as any' casts

We welcome contributions! Please see our Contributing Guide for details.

git clone https://github.com/orchflow/orchflow
cd orchflow/packages/orchflow-claude-flow
npm install
npm run build
npm test

MIT License - see LICENSE for details.

Built with:

• claude-flow - The powerful CLI we extend
• Model Context Protocol - For Claude integration
• tmux - Terminal multiplexing
• TypeScript - Type-safe implementation
• Tokio - Rust async runtime