Multi Agent Coordination

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." 🧬