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

1. Establish baseline metrics and target performance goals.
2. Profile agent workloads and identify coordination bottlenecks.
3. Apply orchestration changes and cost controls incrementally.
4. Validate improvements with repeatable tests and rollbacks.

Execution boundaries

This guide does not authorize spawning agents, remote execution, deployment or external messages. Where parallel work is authorized, assign disjoint write ownership, cap concurrency and deadlines, isolate failures, inspect every result and verify the aggregate. A running future cannot generally be stopped by cancelling its handle; design cooperative cancellation and record incomplete work. Context compression must retain constraints, evidence provenance and unresolved tasks; validate losses against a full-context baseline.

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

This is an orchestration design guide, not a bundled framework. Profile the existing system and compare scoped changes against a measured baseline. Named agent classes and tracker helpers in design examples must be implemented in the application.

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

1. Database Performance Agent

   • Query execution time analysis
   • Index utilization tracking
   • Resource consumption monitoring

2. Application Performance Agent

   • CPU and memory profiling
   • Algorithmic complexity assessment
   • Concurrency and async operation analysis

3. Frontend Performance Agent

   • Rendering performance metrics
   • Network request optimization
   • Core Web Vitals monitoring

Profiling design sketch (not executable)

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 design sketch (not executable)

def compress_context(context, max_tokens=4000):
    # Semantic compression using embedding-based truncation
    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 design sketch (not executable)

class MultiAgentOrchestrator:
    def __init__(self, agents):
        self.agents = agents
        self.execution_queue = PriorityQueue()
        self.performance_tracker = PerformanceTracker()

    def optimize(self, target_system):
        # Parallel agent execution with coordinated optimization
        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.perf