Agent Orchestration Multi Agent Optimize

1---
2name: agent-orchestration-multi-agent-optimize
3description: "Optimize multi-agent systems with coordinated profiling, workload distribution, and cost-aware orchestration. Use when improving agent performance, throughput, or reliability."
4---
5 
6# Multi-Agent Optimization Toolkit
7 
8## Use this skill when
9 
10- Improving multi-agent coordination, throughput, or latency
11- Profiling agent workflows to identify bottlenecks
12- Designing orchestration strategies for complex workflows
13- Optimizing cost, context usage, or tool efficiency
14 
15## Do not use this skill when
16 
17- You only need to tune a single agent prompt
18- There are no measurable metrics or evaluation data
19- The task is unrelated to multi-agent orchestration
20 
21## Instructions
22 
231. Establish baseline metrics and target performance goals.
242. Profile agent workloads and identify coordination bottlenecks.
253. Apply orchestration changes and cost controls incrementally.
264. Validate improvements with repeatable tests and rollbacks.
27 
28## Safety
29 
30- Avoid deploying orchestration changes without regression testing.
31- Roll out changes gradually to prevent system-wide regressions.
32 
33## Role: AI-Powered Multi-Agent Performance Engineering Specialist
34 
35### Context
36 
37The 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.
38 
39### Core Capabilities
40 
41- Intelligent multi-agent coordination
42- Performance profiling and bottleneck identification
43- Adaptive optimization strategies
44- Cross-domain performance optimization
45- Cost and efficiency tracking
46 
47## Arguments Handling
48 
49The tool processes optimization arguments with flexible input parameters:
50 
51- `$TARGET`: Primary system/application to optimize
52- `$PERFORMANCE_GOALS`: Specific performance metrics and objectives
53- `$OPTIMIZATION_SCOPE`: Depth of optimization (quick-win, comprehensive)
54- `$BUDGET_CONSTRAINTS`: Cost and resource limitations
55- `$QUALITY_METRICS`: Performance quality thresholds
56 
57## 1. Multi-Agent Performance Profiling
58 
59### Profiling Strategy
60 
61- Distributed performance monitoring across system layers
62- Real-time metrics collection and analysis
63- Continuous performance signature tracking
64 
65#### Profiling Agents
66 
671. **Database Performance Agent**
68   - Query execution time analysis
69   - Index utilization tracking
70   - Resource consumption monitoring
71 
722. **Application Performance Agent**
73   - CPU and memory profiling
74   - Algorithmic complexity assessment
75   - Concurrency and async operation analysis
76 
773. **Frontend Performance Agent**
78   - Rendering performance metrics
79   - Network request optimization
80   - Core Web Vitals monitoring
81 
82### Profiling Code Example
83 
84```python
85def multi_agent_profiler(target_system):
86    agents = [
87        DatabasePerformanceAgent(target_system),
88        ApplicationPerformanceAgent(target_system),
89        FrontendPerformanceAgent(target_system)
90    ]
91 
92    performance_profile = {}
93    for agent in agents:
94        performance_profile[agent.__class__.__name__] = agent.profile()
95 
96    return aggregate_performance_metrics(performance_profile)
97```
98 
99## 2. Context Window Optimization
100 
101### Optimization Techniques
102 
103- Intelligent context compression
104- Semantic relevance filtering
105- Dynamic context window resizing
106- Token budget management
107 
108### Context Compression Algorithm
109 
110```python
111def compress_context(context, max_tokens=4000):
112    # Semantic compression using embedding-based truncation
113    compressed_context = semantic_truncate(
114        context,
115        max_tokens=max_tokens,
116        importance_threshold=0.7
117    )
118    return compressed_context
119```
120 
121## 3. Agent Coordination Efficiency
122 
123### Coordination Principles
124 
125- Parallel execution design
126- Minimal inter-agent communication overhead
127- Dynamic workload distribution
128- Fault-tolerant agent interactions
129 
130### Orchestration Framework
131 
132```python
133class MultiAgentOrchestrator:
134    def __init__(self, agents):
135        self.agents = agents
136        self.execution_queue = PriorityQueue()
137        self.performance_tracker = PerformanceTracker()
138 
139    def optimize(self, target_system):
140        # Parallel agent execution with coordinated optimization
141        with concurrent.futures.ThreadPoolExecutor() as executor:
142            futures = {
143                executor.submit(agent.optimize, target_system): agent
144                for agent in self.agents
145            }
146 
147            for future in concurrent.futures.as_completed(futures):
148                agent = futures[future]
149                result = future.result()
150                self.performance_tracker.log(agent, result)
151```
152 
153## 4. Parallel Execution Optimization
154 
155### Key Strategies
156 
157- Asynchronous agent processing
158- Workload partitioning
159- Dynamic resource allocation
160- Minimal blocking operations
161 
162## 5. Cost Optimization Strategies
163 
164### LLM Cost Management
165 
166- Token usage tracking
167- Adaptive model selection
168- Caching and result reuse
169- Efficient prompt engineering
170 
171### Cost Tracking Example
172 
173```python
174class CostOptimizer:
175    def __init__(self):
176        self.token_budget = 100000  # Monthly budget
177        self.token_usage = 0
178        self.model_costs = {
179            'gpt-5': 0.03,
180            'claude-4-sonnet': 0.015,
181            'claude-4-haiku': 0.0025
182        }
183 
184    def select_optimal_model(self, complexity):
185        # Dynamic model selection based on task complexity and budget
186        pass
187```
188 
189## 6. Latency Reduction Techniques
190 
191### Performance Acceleration
192 
193- Predictive caching
194- Pre-warming agent contexts
195- Intelligent result memoization
196- Reduced round-trip communication
197 
198## 7. Quality vs Speed Tradeoffs
199 
200### Optimization Spectrum
201 
202- Performance thresholds
203- Acceptable degradation margins
204- Quality-aware optimization
205- Intelligent compromise selection
206 
207## 8. Monitoring and Continuous Improvement
208 
209### Observability Framework
210 
211- Real-time performance dashboards
212- Automated optimization feedback loops
213- Machine learning-driven improvement
214- Adaptive optimization strategies
215 
216## Reference Workflows
217 
218### Workflow 1: E-Commerce Platform Optimization
219 
2201. Initial performance profiling
2212. Agent-based optimization
2223. Cost and performance tracking
2234. Continuous improvement cycle
224 
225### Workflow 2: Enterprise API Performance Enhancement
226 
2271. Comprehensive system analysis
2282. Multi-layered agent optimization
2293. Iterative performance refinement
2304. Cost-efficient scaling strategy
231 
232## Key Considerations
233 
234- Always measure before and after optimization
235- Maintain system stability during optimization
236- Balance performance gains with resource consumption
237- Implement gradual, reversible changes
238 
239Target Optimization: $ARGUMENTS
240