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

Don't Use Multi-Agent When

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)

The Solution: Forward Message

Implement forward_message tool allowing agents to pass responses directly:

def forward_message(message: str, recipient: str = "user"):
    """
    Forward agent response directly without supervisor synthesis.

    Use when:
    - Agent response is final and complete
    - Supervisor synthesis would lose important details
    - Response format must be preserved exactly

    Covenant alignment:
    - No Mock Data: Prevents synthetic summaries
    - Literal Exactness: Preserves original content
    """
    if recipient == "user":
        return {"type": "direct_response", "content": message}
    else:
        return {"type": "agent_input", "content": message, "target": recipient}

Critical implementation note: Supervisor's role is routing, not synthesis. Let specialized agents synthesize when needed.

Token Economics

Cost Multipliers

Cost/Benefit Analysis

Research finding: Upgrading to better models often provides larger performance gains than doubling token budgets. This suggests:

• •Use fewer, stronger agents over many weak agents
• •Use better models before adding more agents
• •Multi-agent is for capability (context isolation, specialization), not just scale

Optimization Strategies

1. •Minimize agent spawning: Only spawn when context isolation genuinely needed
2. •Batch operations: Run independent agents in parallel
3. •Forward directly: Skip supervisor synthesis overhead
4. •Compile context per-agent: Don't send everything to everyone
5. •Checkpoint state: Avoid re-accumulating history

The Pentadyadic Implementation

Architecture Overview

The exocortex implements a specific five-agent system:

Triquetra Evaluation Pattern

The primary coordination pattern for artifact evaluation:

Phase 1: Independent Evaluation (Parallel)
├── Harmonion (semantic lens) ─────┐
└── Critikon (structural lens) ────┼──→ Phase 2
                                   ↓
Phase 2: Synthesis (Sequential)
└── Morphognome (decision + graph write)

Key Constraints:

• •Independence: H and C must not see each other's analysis until Phase 2
• •No mutation: Evaluation phase is read-only
• •Preserve divergence: M does not average away H/C conflicts

Why This Specific Pattern

The pentadyadic pattern exists because:

1. •Semantic vs. Structural: Different evaluation lenses find different issues
2. •Independence prevents groupthink: Parallel evaluation preserves disagreement
3. •Single write authority: Only Morphognome mutates graph (clear responsibility)
4. •Gnomon duality: Archeoform (what persists) + Antimorphogen (what breaks) = completeness

Adapting the Pattern

The pentadyadic is one configuration. Adapt based on needs:

Context Management

Per-Agent Context Compilation

Different agents need different context concentrations:

def compile_context_for_agent(agent, full_context, task):
    """Compile context appropriate to agent's role."""

    concentration = AGENT_CONCENTRATIONS[agent.role]

    if concentration == "high":
        # Full substrate access (e.g., Morphognome)
        return full_context.with_task(task)

    elif concentration == "medium":
        # Domain-relevant context (e.g., Harmonion, Critikon)
        return full_context.filter_to_domain(task.domain).with_task(task)

    elif concentration == "low":
        # Minimal context (e.g., Archeoform, Antimorphogen)
        return task.minimal_context()

Context Isolation Benefits

Multi-agent provides natural context isolation:

Full context: 200K tokens (exceeds limits)
                    ↓ (decompose)
Agent A context: 50K tokens (task-specific)
Agent B context: 40K tokens (different task)
Agent C context: 30K tokens (synthesis only)

Each agent operates in focused context within limits, avoiding degradation from context overflow.

Failure Modes

Mode 1: Supervisor Bottleneck

Symptom: Supervisor accumulates context from all agents, becomes saturated.

Mitigation:

• •Enforce output schemas so agents return distilled summaries
• •Use checkpointing to persist state without carrying history
• •Forward responses directly when possible

Mode 2: Evaluation Divergence

Symptom: Evaluating agents produce incompatible assessments; synthesizer cannot reconcile.

Mitigation:

• •Preserve divergences explicitly (don't average away)
• •Escalate to operator when tensions unresolvable
• •Document divergence patterns for future reference

Mode 3: Sycophancy/Groupthink

Symptom: Agents mimic each other's conclusions without independent reasoning.

Mitigation:

• •Enforce independence in evaluation phase
• •Require evidence-cited reasoning
• •Use adversarial agent (Antimorphogen pattern) to stress-test consensus

Mode 4: Coordination Overhead

Symptom: More time coordinating than executing; diminishing returns.

Mitigation:

• •Question whether multi-agent is needed
• •Reduce agent count if tasks don't decompose naturally
• •Use stronger single agent before adding coordination

Covenant Integration

Context Hygiene

Multi-agent requires disciplined context compilation:

• •Per-agent context (not wholesale dump)
• •Per-turn compilation (not accumulated history)
• •Tiered context (substrate → working → retrieved)

Data Fidelity

Agents cannot invent data to fill gaps:

• •Forward original content, don't paraphrase
• •Preserve uncertainty markers
• •UNKNOWN > INVENTED applies to all agents

Fast-Fail

Check capabilities at spawn time:

• •Required tools available?
• •Context within limits?
• •Authority boundaries clear?

Determinism

Multi-agent coordination should be replayable:

• •Stable agent identities
• •Deterministic context compilation
• •Captured decision trails

Quality Gates

Pre-Coordination

• • Multi-agent justified (not single-agent viable)?
• • Architecture selected (supervisor/peer/hierarchical)?
• • Agent roles defined with clear authority?
• • Context compilation strategy defined?
• • Communication protocol (forward_message) in place?

Post-Coordination

• • All agents operated within context limits?
• • No telephone game fidelity loss?
• • Divergences preserved, not averaged?
• • Coordination overhead acceptable?
• • Results reproducible?

Related Skills

• •covenant-patterns — Context hygiene, data fidelity principles
• •agent-steering — Single-agent configuration (foundation)
• •epistemic-rendering — Different lenses for different agents
• •recipe-assembly — Agent role slice extraction

"Multi-agent is not about more agents. It's about context isolation, specialized evaluation, and clean authority." 🧬