multi-agent-coordination

Files (1)

• SKILL.md

SKILL.md (first lines)

# Multi-Agent Coordination

*Patterns for distributed cognition through specialized agents. The pentadyadic system as one implementation.*

## Overview

Multi-Agent Coordination documents patterns for coordinating multiple AI agents to accomplish tasks that exceed single-agent capabilities. The pentadyadic system (Harmonion, Morphognome, Critikon, Archeoform, Antimorphogen) is one implementation of these patterns, not the only approach.

This skill provides:

- **Coordination architectures** — Supervisor, peer-to-peer, hierarchical
- **Context isolation patterns** — Why multi-agent helps with long contexts
- **Communication protocols** — The telephone game problem and solutions
- **Token economics** — Cost/benefit analysis of multi-agent approaches
- **Implementation patterns** — Pentadyadic as a reference implementation

The core insight: Multi-agent is not about "more agents = better." It's about context isolation, specialized evaluation, and clean authority boundaries.

## When Multi-Agent Makes Sense

### Use Multi-Agent When

| Condition | Why Multi-Agent Helps |
|-----------|----------------------|
| **Context exceeds limits** | Split across agents, each with focused context |
| **Tasks decompose naturally** | Parallel execution, specialized handling |
| **Evaluation needs independence** | Prevent groupthink, preserve disagreement |
| **Different perspectives needed** | Semantic vs. structural vs. adversarial |
| **Authority needs separation** | Read vs. write, evaluate vs. execute |

### Don't Use Multi-Agent When

| Condition | Why Single-Agent Better |
|-----------|------------------------|
| **Task fits in context** | Unnecessary coordination overhead |
| **No natural decomposition** | Artificial splitting harms coherence |
| **Speed critical** | Multi-agent adds latency |
| **Budget constrained** | Token costs multiply significantly |

## Coordination Architectures

### Supervisor Architecture

One agent coordinates, others specialize:

```
           Supervisor
          /    |    \
     Agent A  Agent B  Agent C
     (task)   (task)   (task)
```

**Advantages**:
- Clear authority hierarchy
- Single point of coordination
- Easier to debug

**Disadvantages**:
- Supervisor bottleneck
- Telephone game problem (see below)
- Context accumulation in supervisor

### Peer-to-Peer Architecture

Agents communicate directly:

```
    Agent A ←→ Agent B
       ↑         ↑
       ↓         ↓
    Agent C ←→ Agent D
```

**Advantages**:
- No single bottleneck
- Direct communication
- Scales horizontally

**Disadvantages**:
- Coordination complexity
- Potential for deadlock
- Harder to track state

### Hierarchical Architecture

Nested teams of agents:

```
              Orchestrator
             /           \
      Team Lead A     Team Lead B
       /      \         /      \
    Worker  Worker  Worker  Worker
```

**Advantages**:
- Complex task decomposition
- Localized coordination
- Scalable structure

**Disadvantages**:
- Deep hierarchies lose fidelity
- High coordination overhead
- Complex debugging

## The Telephone Game Problem

### The Problem

Supervisor architectures paraphrase sub-agent responses, losing fidelity. LangGraph benchmarks showed **50% performance degradation** due to this "telephone game" effect.

```
Agent A output: "The function fails when input > 100 due to overflow in line 42"
                    ↓ (supervisor paraphrases)
Supervisor summary: "There's a bug with large inputs"
                    ↓ (critical detail lost)
Agent B receives: "There's a bug with large inputs" (can't fix without specifics)
```

From SyntaxAsSpiral/ConSensus, MIT.

More from SyntaxAsSpiral/ConSensus