claude-code-subagents-orchestrator
Version:
Claude Code Sub-agents Orchestrator - A powerful MCP server for orchestrating multiple AI sub-agents for complex task execution in Claude Code
1,366 lines (1,179 loc) • 45.8 kB
Markdown
# Comprehensive Usage Examples and Workflow Demonstrations
This document provides practical examples of using the Claude Code Subagents Orchestrator for real-world development scenarios.
## Quick Start Examples
### Basic Agent Listing and Installation
```javascript
// Connect to the MCP server
import { MCPClient } from '@modelcontextprotocol/sdk/client/index.js';
const client = new MCPClient({
name: 'example-app',
version: '1.0.0'
});
await client.connect({
command: 'node',
args: ['path/to/orchestrator/server.js']
});
// List available agents
const agents = await client.call('listAgents', {});
console.log(`Found ${agents.totalCount} agents across ${Object.keys(agents.categories).length} categories`);
// Install specific agents if needed
const installation = await client.call('installAgents', {
agents: ['backend-architect', 'frontend-developer', 'devops-engineer'],
force: false
});
console.log(`Successfully installed: ${installation.summary.successful}/${installation.summary.total} agents`);
```
### Simple Delegation Example
```javascript
// Force delegation to a specialist agent
const delegation = await client.call('forceDelegation', {
task: 'Design a RESTful API for a social media platform with user authentication, posts, and real-time messaging',
targetAgent: 'backend-architect',
enforcementLevel: 'strict'
});
// Validate that delegation occurred
const validation = await client.call('validateDelegation', {
originalRequest: {
task: 'Design a RESTful API for a social media platform',
targetAgent: 'backend-architect'
},
response: delegation,
expectedAgent: 'backend-architect'
});
if (validation.delegationOccurred) {
console.log('✅ Task successfully delegated to backend-architect');
console.log('Evidence:', validation.evidence);
} else {
console.error('❌ Delegation failed');
}
```
## Real-World Workflow Examples
### Example 1: E-Commerce Application Development
This example demonstrates building a complete e-commerce application using multiple specialized agents.
```javascript
async function buildECommerceApp() {
console.log('🚀 Starting e-commerce application development...');
// Step 1: Project Analysis and Planning
const projectAnalysis = await client.call('analyzeProjectState', {
projectPath: './ecommerce-app',
includeFileStructure: true,
includeDependencies: true
});
console.log(`📊 Project type: ${projectAnalysis.project.type}`);
console.log(`📋 Recommendations: ${projectAnalysis.recommendations.length}`);
// Step 2: Generate Multi-Agent Workflow
const workflow = await client.call('generateMultiAgentWorkflow', {
task: 'Build a complete e-commerce application with user authentication, product catalog, shopping cart, payment processing, and admin dashboard',
complexity: 'high',
preferredAgents: ['backend-architect', 'frontend-developer', 'database-expert', 'security-engineer', 'devops-engineer'],
constraints: {
maxSteps: 12,
timeoutMs: 7200000, // 2 hours
parallel: true
},
context: {
technologies: ['Node.js', 'React', 'PostgreSQL', 'Redis'],
requirements: ['mobile-responsive', 'payment-integration', 'real-time-updates'],
scale: 'medium-enterprise'
}
});
console.log(`📋 Generated workflow with ${workflow.analysis.requiredAgents.length} agents and ${workflow.workflow.steps.length} steps`);
console.log(`⏱️ Estimated duration: ${Math.round(workflow.analysis.estimatedDuration / 60000)} minutes`);
const results = [];
// Step 3: Execute Backend Architecture
console.log('\n🏗️ Phase 1: Backend Architecture Design');
const backendDesign = await client.call('forceDelegation', {
task: `Design the backend architecture for an e-commerce platform with:
- User authentication and authorization
- Product catalog management
- Shopping cart and order processing
- Payment integration (Stripe/PayPal)
- Inventory management
- Admin dashboard API
- Real-time notifications
Technical requirements:
- Node.js with Express framework
- PostgreSQL for primary data
- Redis for caching and sessions
- JWT authentication
- RESTful API design
- Microservices architecture consideration`,
targetAgent: 'backend-architect',
enforcementLevel: 'strict',
context: {
phase: 'architecture',
technologies: workflow.context.technologies,
scalability: 'horizontal-scaling'
}
});
results.push({
phase: 'backend-architecture',
agent: 'backend-architect',
status: 'completed',
output: backendDesign.output
});
// Step 4: Database Design
console.log('\n🗄️ Phase 2: Database Design');
const databaseDesign = await client.call('forceDelegation', {
task: `Design the database schema for the e-commerce platform based on the backend architecture:
Required entities:
- Users (customers, admins, vendors)
- Products (with variants, categories, inventory)
- Orders (with items, status, payments)
- Shopping carts (persistent, guest support)
- Reviews and ratings
- Payment transactions
- Audit logs
Requirements:
- PostgreSQL with proper indexing
- Data integrity and constraints
- Performance optimization
- Migration strategy
- Backup and recovery plan`,
targetAgent: 'database-expert',
enforcementLevel: 'strict',
context: {
phase: 'database-design',
dependsOn: ['backend-architecture'],
backendSpecs: backendDesign.output
}
});
results.push({
phase: 'database-design',
agent: 'database-expert',
status: 'completed',
output: databaseDesign.output
});
// Step 5: Security Implementation
console.log('\n🔒 Phase 3: Security Implementation');
const securityImplementation = await client.call('forceDelegation', {
task: `Implement comprehensive security measures for the e-commerce platform:
Security requirements:
- JWT authentication with refresh tokens
- Password hashing and validation
- Input validation and sanitization
- SQL injection prevention
- XSS protection
- CSRF protection
- Rate limiting
- Payment data security (PCI compliance)
- Data encryption at rest and in transit
- Security headers and HTTPS enforcement
Integration with:
- Backend architecture specifications
- Database schema design
- Frontend authentication flow`,
targetAgent: 'security-engineer',
enforcementLevel: 'strict',
context: {
phase: 'security',
complianceRequirements: ['PCI-DSS', 'GDPR'],
authenticationMethod: 'JWT'
}
});
results.push({
phase: 'security',
agent: 'security-engineer',
status: 'completed',
output: securityImplementation.output
});
// Step 6: Frontend Development
console.log('\n🎨 Phase 4: Frontend Development');
const frontendDevelopment = await client.call('forceDelegation', {
task: `Develop the frontend application for the e-commerce platform:
Required components and pages:
- User authentication (login, register, profile)
- Product catalog with search and filters
- Product detail pages with reviews
- Shopping cart and checkout flow
- Order history and tracking
- Admin dashboard for product/order management
- Responsive design for mobile devices
- Real-time notifications
Technical requirements:
- React with TypeScript
- State management (Redux or Context API)
- Responsive design (mobile-first)
- Performance optimization
- Accessibility compliance (WCAG 2.1)
- Integration with backend APIs
- Payment flow integration
- Real-time updates (WebSocket)`,
targetAgent: 'frontend-developer',
enforcementLevel: 'strict',
context: {
phase: 'frontend',
framework: 'React',
stateManagement: 'Redux Toolkit',
uiLibrary: 'Material-UI',
backendSpecs: backendDesign.output
}
});
results.push({
phase: 'frontend',
agent: 'frontend-developer',
status: 'completed',
output: frontendDevelopment.output
});
// Step 7: DevOps and Deployment
console.log('\n🚀 Phase 5: DevOps and Deployment');
const devopsDeployment = await client.call('forceDelegation', {
task: `Set up DevOps infrastructure and deployment pipeline for the e-commerce platform:
Infrastructure requirements:
- Docker containerization for all services
- Kubernetes or Docker Compose orchestration
- CI/CD pipeline (GitHub Actions or GitLab CI)
- Environment management (dev, staging, prod)
- Database migrations and seeding
- Redis configuration for caching
- Load balancing and auto-scaling
- Monitoring and logging (Prometheus, Grafana)
- Backup and disaster recovery
- SSL certificates and domain configuration
Deployment targets:
- AWS, Google Cloud, or Azure
- CDN for static assets
- Database hosting (managed PostgreSQL)
- Redis hosting (managed or self-hosted)`,
targetAgent: 'devops-engineer',
enforcementLevel: 'strict',
context: {
phase: 'devops',
cloudProvider: 'AWS',
containerization: 'Docker',
orchestration: 'Kubernetes'
}
});
results.push({
phase: 'devops',
agent: 'devops-engineer',
status: 'completed',
output: devopsDeployment.output
});
// Step 8: Testing Strategy
console.log('\n🧪 Phase 6: Testing Implementation');
const testingImplementation = await client.call('forceDelegation', {
task: `Implement comprehensive testing strategy for the e-commerce platform:
Testing requirements:
- Unit tests for backend API endpoints
- Integration tests for database operations
- Frontend component testing (React Testing Library)
- End-to-end testing (Cypress or Playwright)
- Performance testing for critical paths
- Security testing for authentication and payments
- Load testing for scalability validation
- API contract testing
- Mobile responsiveness testing
Test coverage targets:
- Backend: 90%+ code coverage
- Frontend: 85%+ component coverage
- Critical user flows: 100% e2e coverage
Test automation:
- CI/CD integration
- Automated test runs on PR
- Performance regression testing`,
targetAgent: 'qa-engineer',
enforcementLevel: 'strict',
context: {
phase: 'testing',
testingFrameworks: ['Jest', 'React Testing Library', 'Cypress'],
coverageTargets: { backend: 90, frontend: 85 }
}
});
results.push({
phase: 'testing',
agent: 'qa-engineer',
status: 'completed',
output: testingImplementation.output
});
// Step 9: Final Integration and Validation
console.log('\n🔗 Phase 7: Final Integration');
// Validate all phases completed successfully
const completedPhases = results.filter(r => r.status === 'completed');
const totalPhases = results.length;
if (completedPhases.length === totalPhases) {
console.log(`✅ All ${totalPhases} phases completed successfully!`);
// Generate final deployment guide
const deploymentGuide = await client.call('generateRecoveryPrompt', {
executionContext: {
task: 'E-commerce application development',
completedPhases: results.map(r => r.phase),
agents: results.map(r => r.agent)
},
failedStep: 'none',
errorDetails: {
message: 'All phases completed - generate deployment guide',
code: 'SUCCESS'
},
recoveryOptions: ['finalize']
});
console.log('\n📚 Final deliverables generated:');
results.forEach(result => {
console.log(` ✅ ${result.phase} (${result.agent})`);
});
return {
success: true,
phases: results,
totalDuration: Date.now() - startTime,
deploymentGuide: deploymentGuide
};
} else {
console.error(`❌ ${totalPhases - completedPhases.length} phases failed`);
// Generate recovery strategy for failed phases
const failedPhases = results.filter(r => r.status !== 'completed');
const recovery = await client.call('generateRecoveryPrompt', {
executionContext: {
task: 'E-commerce application development',
completedPhases: completedPhases.map(r => r.phase),
failedPhases: failedPhases.map(r => r.phase)
},
failedStep: failedPhases[0]?.phase || 'unknown',
errorDetails: {
message: `${failedPhases.length} phases failed`,
code: 'PARTIAL_COMPLETION'
},
recoveryOptions: ['retry', 'alternative']
});
return {
success: false,
completedPhases,
failedPhases,
recovery
};
}
}
// Execute the e-commerce workflow
const startTime = Date.now();
const result = await buildECommerceApp();
if (result.success) {
console.log(`\n🎉 E-commerce application development completed in ${Math.round(result.totalDuration / 60000)} minutes`);
} else {
console.log(`\n⚠️ Partial completion - ${result.completedPhases.length} phases successful`);
console.log('Recovery strategy:', result.recovery.recoveryStrategy);
}
```
### Example 2: Legacy System Migration
This example shows how to orchestrate a complex legacy system migration using multiple agents.
```javascript
async function migrateLegacySystem() {
console.log('🔄 Starting legacy system migration workflow...');
// Step 1: Legacy System Analysis
const legacyAnalysis = await client.call('forceDelegation', {
task: `Analyze the legacy monolithic application for migration to microservices:
Analysis requirements:
- Architecture assessment of current monolith
- Identify business domain boundaries
- Database dependency analysis
- Performance bottleneck identification
- Security vulnerability assessment
- Integration point mapping
- Data flow analysis
- Risk assessment for migration
Current system context:
- Java Spring Boot monolith
- MySQL database
- 5 years of technical debt
- 50+ API endpoints
- 10+ business modules
- High coupling between components`,
targetAgent: 'backend-architect',
enforcementLevel: 'strict',
context: {
migrationPhase: 'analysis',
currentTech: ['Java', 'Spring Boot', 'MySQL'],
targetTech: ['Node.js', 'PostgreSQL', 'Docker', 'Kubernetes']
}
});
// Step 2: Migration Strategy Planning
const migrationStrategy = await client.call('forceDelegation', {
task: `Develop a comprehensive migration strategy based on the legacy analysis:
Strategy requirements:
- Phase-by-phase migration plan
- Service decomposition strategy
- Data migration approach
- Zero-downtime migration techniques
- Rollback strategies for each phase
- Risk mitigation plans
- Timeline and resource estimation
- Success criteria definition
Migration approach:
- Strangler Fig pattern implementation
- Database decomposition strategy
- API gateway introduction
- Service mesh consideration
- Monitoring and observability setup`,
targetAgent: 'solution-architect',
enforcementLevel: 'strict',
context: {
migrationPhase: 'strategy',
dependsOn: 'legacy-analysis',
approach: 'strangler-fig-pattern'
}
});
// Step 3: Infrastructure Preparation
const infrastructureSetup = await client.call('forceDelegation', {
task: `Prepare the infrastructure for the microservices migration:
Infrastructure requirements:
- Kubernetes cluster setup
- Service mesh implementation (Istio)
- API gateway deployment
- Monitoring stack (Prometheus, Grafana, Jaeger)
- Logging aggregation (ELK stack)
- CI/CD pipeline setup
- Container registry
- Database migration tools
- Backup and recovery systems
Platform setup:
- AWS EKS or Google GKE
- Infrastructure as Code (Terraform)
- GitOps workflow (ArgoCD)
- Security scanning and compliance`,
targetAgent: 'devops-engineer',
enforcementLevel: 'strict',
context: {
migrationPhase: 'infrastructure',
cloudProvider: 'AWS',
orchestration: 'Kubernetes',
serviceMesh: 'Istio'
}
});
// Step 4: First Microservice Implementation
const firstMicroservice = await client.call('forceDelegation', {
task: `Implement the first microservice as part of the migration strategy:
Microservice requirements:
- Extract user authentication service
- Implement in Node.js with TypeScript
- JWT token management
- User profile management
- Integration with legacy database
- API compatibility with monolith
- Comprehensive logging and monitoring
- Health checks and readiness probes
Technical implementation:
- Express.js framework
- PostgreSQL for user data
- Redis for session management
- Docker containerization
- Kubernetes deployment manifests
- OpenAPI documentation`,
targetAgent: 'backend-developer',
enforcementLevel: 'strict',
context: {
migrationPhase: 'first-service',
serviceName: 'user-authentication',
technology: 'Node.js + TypeScript'
}
});
// Step 5: Data Migration Planning
const dataMigration = await client.call('forceDelegation', {
task: `Plan and implement data migration for the extracted microservice:
Data migration requirements:
- Extract user data from legacy MySQL
- Transform to new PostgreSQL schema
- Implement dual-write pattern during transition
- Data consistency validation
- Rollback procedures
- Performance optimization
- Zero-downtime migration execution
Migration tools and techniques:
- Database migration scripts
- Data validation tools
- CDC (Change Data Capture) setup
- Sync verification processes
- Migration monitoring and alerting`,
targetAgent: 'data-engineer',
enforcementLevel: 'strict',
context: {
migrationPhase: 'data-migration',
sourceDB: 'MySQL',
targetDB: 'PostgreSQL',
migrationPattern: 'dual-write'
}
});
// Step 6: Testing and Validation
const migrationTesting = await client.call('forceDelegation', {
task: `Implement comprehensive testing for the migration:
Testing requirements:
- Integration testing between microservice and monolith
- Data consistency testing
- Performance testing (load and stress)
- Security testing for new authentication service
- End-to-end user journey testing
- Rollback procedure testing
- Monitoring and alerting validation
Test automation:
- Automated integration test suite
- Performance regression testing
- Security vulnerability scanning
- Infrastructure testing (chaos engineering)`,
targetAgent: 'qa-engineer',
enforcementLevel: 'strict',
context: {
migrationPhase: 'testing',
testTypes: ['integration', 'performance', 'security', 'e2e'],
automationLevel: 'high'
}
});
// Step 7: Gradual Rollout
const gradualRollout = await client.call('forceDelegation', {
task: `Plan and execute gradual rollout of the new microservice:
Rollout requirements:
- Blue-green deployment strategy
- Feature flag implementation
- Traffic splitting (canary deployment)
- Real-time monitoring and alerting
- Automatic rollback triggers
- User experience monitoring
- Performance metrics tracking
Rollout phases:
- 5% traffic to new service
- 25% traffic if metrics are healthy
- 50% traffic with continued monitoring
- 100% traffic with legacy service backup
- Legacy service decommissioning`,
targetAgent: 'devops-engineer',
enforcementLevel: 'strict',
context: {
migrationPhase: 'rollout',
strategy: 'blue-green-canary',
trafficSplitSteps: [5, 25, 50, 100]
}
});
console.log('✅ Legacy system migration workflow completed successfully!');
return {
success: true,
phases: [
{ name: 'Legacy Analysis', status: 'completed' },
{ name: 'Migration Strategy', status: 'completed' },
{ name: 'Infrastructure Setup', status: 'completed' },
{ name: 'First Microservice', status: 'completed' },
{ name: 'Data Migration', status: 'completed' },
{ name: 'Testing & Validation', status: 'completed' },
{ name: 'Gradual Rollout', status: 'completed' }
]
};
}
```
### Example 3: Performance Optimization Project
This example demonstrates using multiple specialist agents for a comprehensive performance optimization project.
```javascript
async function optimizeApplicationPerformance() {
console.log('⚡ Starting application performance optimization...');
// Step 1: Performance Analysis and Profiling
const performanceAnalysis = await client.call('forceDelegation', {
task: `Conduct comprehensive performance analysis of the application:
Analysis scope:
- Frontend performance metrics (Core Web Vitals)
- Backend API response times and throughput
- Database query performance and optimization
- Network latency and bandwidth usage
- Memory usage and garbage collection patterns
- CPU utilization and bottlenecks
- Cache hit rates and effectiveness
- Third-party service dependencies
Tools and metrics:
- Google Lighthouse for frontend
- APM tools (New Relic, DataDog) for backend
- Database slow query logs
- Browser developer tools analysis
- Load testing with k6 or Artillery
- Memory profiling tools
Current performance baseline:
- Page load time: 4.2 seconds
- API response time: 800ms average
- Database queries: 150ms average
- Memory usage: 512MB average`,
targetAgent: 'performance-engineer',
enforcementLevel: 'strict',
context: {
optimizationPhase: 'analysis',
currentMetrics: {
pageLoadTime: 4200,
apiResponseTime: 800,
dbQueryTime: 150
},
targetMetrics: {
pageLoadTime: 2000,
apiResponseTime: 300,
dbQueryTime: 50
}
}
});
// Step 2: Frontend Optimization
const frontendOptimization = await client.call('forceDelegation', {
task: `Optimize frontend performance based on the analysis:
Frontend optimization tasks:
- Bundle size reduction and code splitting
- Image optimization and lazy loading
- CSS optimization and critical path
- JavaScript minification and tree shaking
- Service worker implementation for caching
- Preloading and prefetching strategies
- Font optimization and loading
- Third-party script optimization
- Progressive Web App features
Specific improvements:
- Implement React.lazy() for code splitting
- Optimize images with WebP format
- Implement virtual scrolling for large lists
- Add service worker for offline capability
- Optimize CSS delivery and remove unused styles
- Implement preconnect for external resources
Target improvements:
- Reduce bundle size by 40%
- Improve LCP (Largest Contentful Paint) to <2s
- Achieve CLS (Cumulative Layout Shift) <0.1
- Improve FID (First Input Delay) to <100ms`,
targetAgent: 'frontend-developer',
enforcementLevel: 'strict',
context: {
optimizationPhase: 'frontend',
framework: 'React',
bundler: 'Webpack',
targetMetrics: {
bundleReduction: 40,
lcp: 2000,
cls: 0.1,
fid: 100
}
}
});
// Step 3: Backend API Optimization
const backendOptimization = await client.call('forceDelegation', {
task: `Optimize backend API performance:
Backend optimization tasks:
- Database query optimization and indexing
- API response caching strategy
- Connection pooling optimization
- Microservice communication optimization
- Background job processing improvements
- Memory leak identification and fixes
- CPU usage optimization
- Async/await pattern optimization
Specific improvements:
- Implement Redis caching for frequent queries
- Add database connection pooling
- Optimize N+1 query problems
- Implement pagination for large datasets
- Add compression for API responses
- Optimize JSON serialization
- Implement request rate limiting
- Add database read replicas
Target improvements:
- Reduce API response time from 800ms to 300ms
- Increase throughput by 3x
- Reduce database query time by 70%
- Improve cache hit rate to 90%`,
targetAgent: 'backend-architect',
enforcementLevel: 'strict',
context: {
optimizationPhase: 'backend',
technology: 'Node.js + Express',
database: 'PostgreSQL',
caching: 'Redis'
}
});
// Step 4: Database Optimization
const databaseOptimization = await client.call('forceDelegation', {
task: `Optimize database performance:
Database optimization tasks:
- Query performance analysis and optimization
- Index creation and optimization
- Database schema optimization
- Connection pool tuning
- Query plan analysis
- Database statistics update
- Partition strategy implementation
- Read replica configuration
Specific improvements:
- Create composite indexes for frequent queries
- Optimize slow queries identified in analysis
- Implement query result caching
- Add database monitoring and alerting
- Optimize table partitioning strategy
- Implement connection pooling
- Add read replicas for reporting queries
- Optimize database configuration parameters
Target improvements:
- Reduce query execution time by 70%
- Improve index utilization to 95%
- Reduce database CPU usage by 50%
- Achieve 99.9% uptime`,
targetAgent: 'database-expert',
enforcementLevel: 'strict',
context: {
optimizationPhase: 'database',
dbType: 'PostgreSQL',
currentQueries: 'slow_query_analysis.sql',
targetPerformance: {
queryTimeReduction: 70,
indexUtilization: 95,
cpuReduction: 50
}
}
});
// Step 5: Infrastructure and DevOps Optimization
const infrastructureOptimization = await client.call('forceDelegation', {
task: `Optimize infrastructure and deployment pipeline:
Infrastructure optimization tasks:
- Container optimization and resource tuning
- Kubernetes resource allocation optimization
- CDN configuration and optimization
- Load balancer optimization
- Auto-scaling configuration
- Monitoring and alerting optimization
- CI/CD pipeline performance improvement
- Security scanning optimization
Specific improvements:
- Optimize Docker images for smaller size
- Configure horizontal pod autoscaling
- Implement CDN for static assets
- Optimize load balancer health checks
- Add performance monitoring dashboards
- Implement blue-green deployments
- Optimize build pipeline caching
- Add performance regression testing
Target improvements:
- Reduce deployment time by 50%
- Improve auto-scaling response time
- Achieve 99.99% availability
- Reduce infrastructure costs by 30%`,
targetAgent: 'devops-engineer',
enforcementLevel: 'strict',
context: {
optimizationPhase: 'infrastructure',
platform: 'Kubernetes',
cloudProvider: 'AWS',
monitoring: 'Prometheus + Grafana'
}
});
// Step 6: Performance Testing and Validation
const performanceTesting = await client.call('forceDelegation', {
task: `Implement comprehensive performance testing:
Performance testing requirements:
- Load testing for normal traffic patterns
- Stress testing for peak capacity
- Spike testing for traffic surges
- Volume testing for large datasets
- Endurance testing for memory leaks
- Browser performance testing
- Mobile performance testing
- API performance testing
Testing scenarios:
- Simulate 1000 concurrent users
- Test with 10x normal database load
- Validate performance under failover conditions
- Test performance with slow network conditions
- Validate caching effectiveness
- Test auto-scaling behavior
Success criteria:
- Page load time <2 seconds (95th percentile)
- API response time <300ms (95th percentile)
- System remains stable under 10x load
- No memory leaks during 24-hour test
- All Core Web Vitals in green`,
targetAgent: 'qa-engineer',
enforcementLevel: 'strict',
context: {
optimizationPhase: 'testing',
testingTools: ['k6', 'Artillery', 'Lighthouse CI'],
loadTestScenarios: {
normalLoad: 100,
peakLoad: 1000,
stressLoad: 5000
}
}
});
// Step 7: Monitoring and Alerting Setup
const monitoringSetup = await client.call('forceDelegation', {
task: `Set up comprehensive performance monitoring:
Monitoring requirements:
- Real User Monitoring (RUM) implementation
- Synthetic monitoring for critical paths
- Application Performance Monitoring (APM)
- Infrastructure monitoring
- Database performance monitoring
- Business metrics tracking
- Error tracking and alerting
- Performance regression detection
Specific implementations:
- Google Analytics and Core Web Vitals tracking
- Datadog or New Relic APM setup
- Prometheus metrics collection
- Grafana dashboard creation
- PagerDuty alerting integration
- Performance budget alerts
- SLA/SLO monitoring
- Automated performance reports
Alert thresholds:
- Page load time >3 seconds
- API response time >500ms
- Error rate >1%
- CPU usage >80%
- Memory usage >85%
- Database connections >90% of pool`,
targetAgent: 'devops-engineer',
enforcementLevel: 'strict',
context: {
optimizationPhase: 'monitoring',
monitoringStack: ['Prometheus', 'Grafana', 'Datadog'],
alertingChannels: ['PagerDuty', 'Slack']
}
});
console.log('✅ Performance optimization project completed successfully!');
// Generate performance improvement report
const improvementReport = {
success: true,
phases: [
{ name: 'Performance Analysis', status: 'completed', duration: '2 hours' },
{ name: 'Frontend Optimization', status: 'completed', duration: '8 hours' },
{ name: 'Backend Optimization', status: 'completed', duration: '12 hours' },
{ name: 'Database Optimization', status: 'completed', duration: '6 hours' },
{ name: 'Infrastructure Optimization', status: 'completed', duration: '4 hours' },
{ name: 'Performance Testing', status: 'completed', duration: '6 hours' },
{ name: 'Monitoring Setup', status: 'completed', duration: '4 hours' }
],
expectedImprovements: {
pageLoadTime: { before: '4.2s', after: '<2s', improvement: '52%' },
apiResponseTime: { before: '800ms', after: '<300ms', improvement: '62%' },
databaseQueries: { before: '150ms', after: '<50ms', improvement: '67%' },
bundleSize: { before: '2.1MB', after: '<1.3MB', improvement: '38%' },
coreWebVitals: { before: 'Poor', after: 'Good', improvement: 'Significant' }
},
totalEffort: '42 hours',
estimatedBusinessImpact: {
conversionImprovement: '15-25%',
userSatisfaction: '+30%',
searchRanking: '+20%',
serverCosts: '-30%'
}
};
return improvementReport;
}
```
## Error Handling and Recovery Examples
### Example 1: Delegation Failure Recovery
```javascript
async function robustTaskExecution(task, preferredAgent) {
const maxRetries = 3;
let retryCount = 0;
while (retryCount < maxRetries) {
try {
console.log(`🎯 Attempt ${retryCount + 1}: Delegating to ${preferredAgent}`);
// Attempt delegation
const delegation = await client.call('forceDelegation', {
task,
targetAgent: preferredAgent,
enforcementLevel: 'strict',
context: { retryCount }
});
// Validate delegation success
const validation = await client.call('validateDelegation', {
originalRequest: { task, targetAgent: preferredAgent },
response: delegation,
expectedAgent: preferredAgent
});
if (validation.delegationOccurred) {
console.log('✅ Delegation successful');
return delegation;
} else {
throw new Error('Delegation validation failed');
}
} catch (error) {
console.warn(`⚠️ Attempt ${retryCount + 1} failed: ${error.message}`);
retryCount++;
if (retryCount >= maxRetries) {
// Generate recovery strategy
const recovery = await client.call('generateRecoveryPrompt', {
executionContext: {
task,
selectedAgent: preferredAgent,
retryCount,
maxRetries
},
failedStep: 'delegation',
errorDetails: {
message: error.message,
code: 'MAX_RETRIES_EXCEEDED'
},
recoveryOptions: ['alternative', 'rollback']
});
console.log(`🔄 Recovery strategy: ${recovery.recoveryStrategy}`);
if (recovery.recoveryStrategy === 'alternative' && recovery.alternativeAgent) {
console.log(`🔀 Trying alternative agent: ${recovery.alternativeAgent}`);
return await robustTaskExecution(task, recovery.alternativeAgent);
} else {
throw new Error(`Task failed after ${maxRetries} attempts: ${error.message}`);
}
}
// Wait before retry
await new Promise(resolve => setTimeout(resolve, 2000 * retryCount));
}
}
}
```
### Example 2: Multi-Agent Workflow with Error Recovery
```javascript
async function resilientWorkflow(complexTask) {
const workflow = await client.call('generateMultiAgentWorkflow', {
task: complexTask,
complexity: 'high'
});
const results = [];
const failedSteps = [];
for (let i = 0; i < workflow.workflow.steps.length; i++) {
const step = workflow.workflow.steps[i];
try {
console.log(`🔄 Executing step ${i + 1}/${workflow.workflow.steps.length}: ${step.description}`);
const result = await robustTaskExecution(step.task, step.agent);
results.push({
stepNumber: i + 1,
step: step.description,
agent: step.agent,
status: 'completed',
result: result
});
console.log(`✅ Step ${i + 1} completed successfully`);
} catch (error) {
console.error(`❌ Step ${i + 1} failed: ${error.message}`);
failedSteps.push({
stepNumber: i + 1,
step: step.description,
agent: step.agent,
error: error.message
});
// Check if this step is critical
if (step.critical !== false) {
console.log('🚨 Critical step failed - generating recovery strategy');
const recovery = await client.call('generateRecoveryPrompt', {
executionContext: {
task: complexTask,
completedSteps: results.map(r => r.step),
failedStep: step.description,
remainingSteps: workflow.workflow.steps.slice(i + 1).map(s => s.description)
},
failedStep: step.description,
errorDetails: {
message: error.message,
code: 'STEP_EXECUTION_FAILED'
},
recoveryOptions: ['retry', 'skip', 'alternative']
});
if (recovery.recoveryStrategy === 'retry') {
console.log('🔄 Retrying failed step...');
i--; // Retry current step
continue;
} else if (recovery.recoveryStrategy === 'skip') {
console.log('⏭️ Skipping failed step...');
results.push({
stepNumber: i + 1,
step: step.description,
agent: step.agent,
status: 'skipped',
reason: 'Recovery strategy: skip'
});
} else {
console.log('🛑 Workflow stopped due to critical failure');
break;
}
} else {
console.log('⚠️ Non-critical step failed - continuing workflow');
results.push({
stepNumber: i + 1,
step: step.description,
agent: step.agent,
status: 'failed',
error: error.message
});
}
}
}
const successfulSteps = results.filter(r => r.status === 'completed').length;
const totalSteps = workflow.workflow.steps.length;
console.log(`\n📊 Workflow Summary:`);
console.log(`✅ Successful steps: ${successfulSteps}/${totalSteps}`);
console.log(`❌ Failed steps: ${failedSteps.length}`);
console.log(`⏭️ Skipped steps: ${results.filter(r => r.status === 'skipped').length}`);
return {
success: successfulSteps > totalSteps * 0.8, // 80% success threshold
totalSteps,
successfulSteps,
failedSteps,
results,
workflowCompleted: successfulSteps === totalSteps
};
}
```
## Performance Monitoring and Optimization
### Real-Time Delegation Monitoring
```javascript
async function monitorDelegationPerformance() {
console.log('📊 Starting delegation performance monitoring...');
const monitoringInterval = setInterval(async () => {
try {
// Get current metrics
const metrics = await client.call('delegationMetrics', {});
console.log('\n📈 Delegation Metrics:');
console.log(` Success Rate: ${(metrics.summary.successRate * 100).toFixed(1)}%`);
console.log(` Bypass Prevention: ${(metrics.summary.bypassPreventionRate * 100).toFixed(1)}%`);
console.log(` Average Execution Time: ${metrics.summary.averageExecutionTime}ms`);
console.log(` Active Agents: ${metrics.summary.activeAgents}`);
console.log(` Total Delegations: ${metrics.summary.totalDelegations}`);
// Check for performance issues
if (metrics.summary.successRate < 0.9) {
console.warn('⚠️ WARNING: Delegation success rate below 90%');
// Analyze failing agents
for (const [agentId, health] of Object.entries(metrics.health)) {
if (health.successRate < 0.8) {
console.warn(` 🔴 Agent ${agentId}: ${(health.successRate * 100).toFixed(1)}% success rate`);
}
}
}
if (metrics.summary.bypassPreventionRate < 0.95) {
console.error('🚨 CRITICAL: Claude Code bypass detected - delegation enforcement failing');
// Attempt to reset enforcement
await client.call('delegationConfig', {
enforcementLevel: 'strict'
});
console.log('🔧 Enforcement level reset to strict');
}
if (metrics.summary.averageExecutionTime > 10000) { // 10 seconds
console.warn('⚠️ WARNING: Average execution time exceeding 10 seconds');
}
} catch (error) {
console.error('❌ Error monitoring delegation performance:', error.message);
}
}, 30000); // Monitor every 30 seconds
// Stop monitoring after 10 minutes
setTimeout(() => {
clearInterval(monitoringInterval);
console.log('📊 Monitoring session ended');
}, 600000);
return monitoringInterval;
}
// Start monitoring
const monitoring = await monitorDelegationPerformance();
```
### Delegation Health Check
```javascript
async function performDelegationHealthCheck() {
console.log('🏥 Performing comprehensive delegation health check...');
const healthReport = {
timestamp: new Date(),
agentAvailability: {},
delegationTest: {},
systemHealth: {},
recommendations: []
};
try {
// Check agent availability
const agents = await client.call('listAgents', {});
healthReport.agentAvailability = {
totalAgents: agents.totalCount,
categories: agents.categories,
status: 'healthy'
};
console.log(`📋 Found ${agents.totalCount} agents across ${Object.keys(agents.categories).length} categories`);
// Test delegation with each agent type
const testAgents = ['backend-architect', 'frontend-developer', 'devops-engineer'];
for (const agentName of testAgents) {
try {
console.log(`🧪 Testing delegation to ${agentName}...`);
const testStart = Date.now();
const testDelegation = await client.call('forceDelegation', {
task: `Health check test task for ${agentName}`,
targetAgent: agentName,
enforcementLevel: 'strict'
});
const testDuration = Date.now() - testStart;
const validation = await client.call('validateDelegation', {
originalRequest: { task: 'health check', targetAgent: agentName },
response: testDelegation,
expectedAgent: agentName
});
healthReport.delegationTest[agentName] = {
status: validation.delegationOccurred ? 'healthy' : 'unhealthy',
responseTime: testDuration,
delegationOccurred: validation.delegationOccurred,
claudeCodeBypassed: validation.claudeCodeBypassed,
evidence: validation.evidence
};
if (validation.delegationOccurred) {
console.log(` ✅ ${agentName}: Healthy (${testDuration}ms)`);
} else {
console.log(` ❌ ${agentName}: Unhealthy - delegation failed`);
healthReport.recommendations.push(`Investigate delegation issues with ${agentName}`);
}
} catch (error) {
console.log(` 🔴 ${agentName}: Error - ${error.message}`);
healthReport.delegationTest[agentName] = {
status: 'error',
error: error.message
};
healthReport.recommendations.push(`Fix delegation errors for ${agentName}: ${error.message}`);
}
}
// Get system metrics
const metrics = await client.call('delegationMetrics', {});
healthReport.systemHealth = {
successRate: metrics.summary.successRate,
bypassPreventionRate: metrics.summary.bypassPreventionRate,
averageExecutionTime: metrics.summary.averageExecutionTime,
activeAgents: metrics.summary.activeAgents,
totalDelegations: metrics.summary.totalDelegations
};
// Generate recommendations based on metrics
if (metrics.summary.successRate < 0.95) {
healthReport.recommendations.push('Success rate below 95% - investigate failing delegations');
}
if (metrics.summary.bypassPreventionRate < 0.98) {
healthReport.recommendations.push('Bypass prevention below 98% - check enforcement configuration');
}
if (metrics.summary.averageExecutionTime > 5000) {
healthReport.recommendations.push('Average execution time over 5s - investigate performance issues');
}
// Overall health score
const healthyAgents = Object.values(healthReport.delegationTest).filter(t => t.status === 'healthy').length;
const totalTestedAgents = Object.keys(healthReport.delegationTest).length;
const agentHealthScore = healthyAgents / totalTestedAgents;
const systemHealthScore = (metrics.summary.successRate + metrics.summary.bypassPreventionRate) / 2;
const overallHealth = (agentHealthScore + systemHealthScore) / 2;
healthReport.overallHealth = {
score: overallHealth,
grade: overallHealth > 0.95 ? 'A' : overallHealth > 0.9 ? 'B' : overallHealth > 0.8 ? 'C' : 'D',
status: overallHealth > 0.9 ? 'healthy' : overallHealth > 0.7 ? 'warning' : 'critical'
};
console.log(`\n🏥 Health Check Summary:`);
console.log(`Overall Health: ${healthReport.overallHealth.grade} (${(overallHealth * 100).toFixed(1)}%)`);
console.log(`Status: ${healthReport.overallHealth.status.toUpperCase()}`);
console.log(`Agent Health: ${healthyAgents}/${totalTestedAgents} agents healthy`);
console.log(`System Health: ${(systemHealthScore * 100).toFixed(1)}%`);
if (healthReport.recommendations.length > 0) {
console.log(`\n📋 Recommendations (${healthReport.recommendations.length}):`);
healthReport.recommendations.forEach((rec, i) => {
console.log(` ${i + 1}. ${rec}`);
});
} else {
console.log('\n✅ No issues found - system is healthy');
}
} catch (error) {
console.error('❌ Health check failed:', error.message);
healthReport.error = error.message;
healthReport.overallHealth = {
score: 0,
grade: 'F',
status: 'critical'
};
}
return healthReport;
}
// Run health check
const healthCheck = await performDelegationHealthCheck();
```
These comprehensive examples demonstrate the power and flexibility of the Claude Code Subagents Orchestrator for complex, real-world development scenarios. The examples show how to:
1. **Build complete applications** with multiple specialist agents working in coordination
2. **Handle complex migrations** with proper planning and risk mitigation
3. **Optimize system performance** across all layers of the stack
4. **Implement robust error handling** and recovery strategies
5. **Monitor system health** and performance in real-time
Each example includes detailed error handling, validation, and monitoring to ensure reliable execution in production environments.