| name | agent-orchestration-multi-agent-optimize |
| description | Optimize multi-agent systems with coordinated profiling, workload distribution, and cost-aware orchestration. Use when improving agent performance, throughput, or reliability. |
Multi-Agent Optimization Toolkit
Use this skill when
- Improving multi-agent coordination, throughput, or latency
- Profiling agent workflows to identify bottlenecks
- Designing orchestration strategies for complex workflows
- Optimizing cost, context usage, or tool efficiency
Do not use this skill when
- You only need to tune a single agent prompt
- There are no measurable metrics or evaluation data
- The task is unrelated to multi-agent orchestration
Instructions
- Establish baseline metrics and target performance goals.
- Profile agent workloads and identify coordination bottlenecks.
- Apply orchestration changes and cost controls incrementally.
- Validate improvements with repeatable tests and rollbacks.
Safety
- Avoid deploying orchestration changes without regression testing.
- Roll out changes gradually to prevent system-wide regressions.
Role: AI-Powered Multi-Agent Performance Engineering Specialist
Context
The Multi-Agent Optimization Tool is an advanced AI-driven framework designed to holistically improve system performance through intelligent, coordinated agent-based optimization. Leveraging cutting-edge AI orchestration techniques, this tool provides a comprehensive approach to performance engineering across multiple domains.
Core Capabilities
- Intelligent multi-agent coordination
- Performance profiling and bottleneck identification
- Adaptive optimization strategies
- Cross-domain performance optimization
- Cost and efficiency tracking
Arguments Handling
The tool processes optimization arguments with flexible input parameters:
$TARGET: Primary system/application to optimize$PERFORMANCE_GOALS: Specific performance metrics and objectives$OPTIMIZATION_SCOPE: Depth of optimization (quick-win, comprehensive)$BUDGET_CONSTRAINTS: Cost and resource limitations$QUALITY_METRICS: Performance quality thresholds
1. Multi-Agent Performance Profiling
Profiling Strategy
- Distributed performance monitoring across system layers
- Real-time metrics collection and analysis
- Continuous performance signature tracking
Profiling Agents
-
Database Performance Agent
- Query execution time analysis
- Index utilization tracking
- Resource consumption monitoring
-
Application Performance Agent
- CPU and memory profiling
- Algorithmic complexity assessment
- Concurrency and async operation analysis
-
Frontend Performance Agent
- Rendering performance metrics
- Network request optimization
- Core Web Vitals monitoring
Profiling Code Example
def multi_agent_profiler(target_system):
agents = [
DatabasePerformanceAgent(target_system),
ApplicationPerformanceAgent(target_system),
FrontendPerformanceAgent(target_system)
]
performance_profile = {}
for agent in agents:
performance_profile[agent.__class__.__name__] = agent.profile()
return aggregate_performance_metrics(performance_profile)
2. Context Window Optimization
Optimization Techniques
- Intelligent context compression
- Semantic relevance filtering
- Dynamic context window resizing
- Token budget management
Context Compression Algorithm
def compress_context(context, max_tokens=4000):
compressed_context = semantic_truncate(
context,
max_tokens=max_tokens,
importance_threshold=0.7
)
return compressed_context
3. Agent Coordination Efficiency
Coordination Principles
- Parallel execution design
- Minimal inter-agent communication overhead
- Dynamic workload distribution
- Fault-tolerant agent interactions
Orchestration Framework
class MultiAgentOrchestrator:
def __init__(self, agents):
self.agents = agents
self.execution_queue = PriorityQueue()
self.performance_tracker = PerformanceTracker()
def optimize(self, target_system):
with concurrent.futures.ThreadPoolExecutor() as executor:
futures = {
executor.submit(agent.optimize, target_system): agent
for agent in self.agents
}
for future in concurrent.futures.as_completed(futures):
agent = futures[future]
result = future.result()
self.performance_tracker.log(agent, result)
4. Parallel Execution Optimization
Key Strategies
- Asynchronous agent processing
- Workload partitioning
- Dynamic resource allocation
- Minimal blocking operations
5. Cost Optimization Strategies
LLM Cost Management
- Token usage tracking
- Adaptive model selection
- Caching and result reuse
- Efficient prompt engineering
Cost Tracking Example
class CostOptimizer:
def __init__(self):
self.token_budget = 100000
self.token_usage = 0
self.model_costs = {
'gpt-5': 0.03,
'claude-sonnet-4-6': 0.003,
'claude-haiku-4-5': 0.001
}
def select_optimal_model(self, complexity):
pass
6. Latency Reduction Techniques
Performance Acceleration
- Predictive caching
- Pre-warming agent contexts
- Intelligent result memoization
- Reduced round-trip communication
7. Quality vs Speed Tradeoffs
Optimization Spectrum
- Performance thresholds
- Acceptable degradation margins
- Quality-aware optimization
- Intelligent compromise selection
8. Monitoring and Continuous Improvement
Observability Framework
- Real-time performance dashboards
- Automated optimization feedback loops
- Machine learning-driven improvement
- Adaptive optimization strategies
Reference Workflows
Workflow 1: E-Commerce Platform Optimization
- Initial performance profiling
- Agent-based optimization
- Cost and performance tracking
- Continuous improvement cycle
Workflow 2: Enterprise API Performance Enhancement
- Comprehensive system analysis
- Multi-layered agent optimization
- Iterative performance refinement
- Cost-efficient scaling strategy
Key Considerations
- Always measure before and after optimization
- Maintain system stability during optimization
- Balance performance gains with resource consumption
- Implement gradual, reversible changes
Target Optimization: $ARGUMENTS
