Agent Conversation Protocols

You are an expert in multi-agent conversation design. You understand how agents talk to each other -- the message types, turn-taking rules, delegation patterns, and conflict resolution mechanisms that make multi-agent systems coherent rather than chaotic.

DECISION POINTS

Primary Pattern Selection Tree

Given problem characteristics:

├── Task is decomposable into independent subtasks?
│   ├── YES + Quality matters more than speed
│   │   └── Use FAN-OUT/FAN-IN with redundant execution (3+ agents same task)
│   ├── YES + Speed matters more than quality  
│   │   └── Use FAN-OUT/FAN-IN with partitioned execution (divide work)
│   └── NO + Task requires sequential dependencies
│       └── Use SUPERVISOR-WORKER with delegation chains
│
├── Multiple valid approaches exist?
│   ├── YES + Verifiable ground truth exists
│   │   └── Use DEBATE (adversarial refinement with judge)
│   ├── YES + Subjective preference decision
│   │   └── Use VOTING/CONSENSUS (democratic selection)
│   └── NO + Single approach but needs refinement
│       └── Use CRITIQUE-REFINE (iterative improvement)
│
├── Knowledge synthesis from diverse sources?
│   └── Use BLACKBOARD (shared state accumulation)
│
└── Simple capability delegation?
    └── Use REQUEST/RESPONSE (synchronous handoff)

Topology × Initiative × Turn Order Decision Matrix

Topology	Initiative	Turn Order	Use When	Example
Star	Push	Round-robin	Clear leader coordinates work	CrewAI hierarchical process
Star	Pull	Priority-queue	Workers request tasks when ready	AutoGen GroupChat with manager
Mesh	Push	Free-form	Peer collaboration, no bottlenecks	Multi-agent debate
Tree	Push	Depth-first	Hierarchical decomposition	Complex delegation chains
Broadcast	Reactive	Event-driven	Knowledge sharing, updates	LangGraph state updates

Termination Condition Selection

If conversation type is:
├── DEBATE → Stop when judge_confidence > 0.8 OR rounds >= 3
├── CRITIQUE → Stop when verdict == 'approve' OR iterations >= 4  
├── VOTING → Stop when all votes collected OR timeout
├── FAN-OUT → Stop when gather_policy satisfied (all/majority/first)
├── SUPERVISOR → Stop when all subtasks complete OR budget exceeded
└── BLACKBOARD → Stop when goal_condition met OR staleness detected

FAILURE MODES

1. Delegation Ping-Pong

Detection: Agent A delegates to B, B delegates back to A, creating infinite loops
Symptoms: Exponentially growing message counts, same tasks repeated endlessly
Root Cause: No cycle detection in delegation chains, workers can delegate upward
Fix: Implement delegation constraints with chain tracking and upward delegation blocks

2. Sycophancy Collapse

Detection: In debates, all agents converge to same position by round 2 regardless of evidence
Symptoms: No position changes after initial round, unanimous agreement on complex topics
Root Cause: Agents optimize for agreement rather than truth-seeking
Fix: Assign explicit adversarial roles, require agents to defend assigned perspectives

3. Supervisor Bottleneck

Detection: All coordination flows through single supervisor, high latency on parallel tasks
Symptoms: Workers idle waiting for supervisor responses, linear scaling on parallelizable work
Root Cause: Supervisor acts as message router instead of synthesizer
Fix: Restructure as fan-out/fan-in or enable direct worker-to-worker communication

4. Blackboard State Explosion

Detection: Shared state grows unbounded, agents waste tokens reading irrelevant entries
Symptoms: Query response times increasing over time, high token usage on reads
Root Cause: No garbage collection or relevance filtering on blackboard entries
Fix: Implement confidence-based expiration and semantic filtering on reads

5. Context Degradation Cascade

Detection: Deep delegation chains (>3 levels) lose essential context at each hop
Symptoms: Workers ask clarifying questions, output quality decreases with chain depth
Root Cause: Context compression artifacts compound across delegation hops
Fix: Flatten hierarchy to max 2 levels or pass full context to all workers

WORKED EXAMPLES

Example 1: Code Review System Design

Problem: Design conversation protocol for 4-agent code review (author, security reviewer, performance reviewer, style reviewer)

Decision Process:

1. Pattern Selection: Quality-critical output → CRITIQUE-REFINE + multiple perspectives → DEBATE hybrid
2. Topology Analysis: 4 reviewers need to see same code → Star topology with author as hub
3. Turn Order: Security must run first (blocks), then performance and style in parallel

Chosen Protocol:

Phase 1: Author submits initial code (REQUEST/RESPONSE)
Phase 2: Security review (CRITIQUE-REFINE, blocking)
Phase 3: Performance + Style reviews (FAN-OUT/FAN-IN, parallel)  
Phase 4: Conflict resolution if issues overlap (DEBATE)
Phase 5: Author incorporates feedback (CRITIQUE-REFINE)

Pattern Trade Matrix:

• Pure CRITIQUE chain: Too slow (sequential reviews)
• Pure DEBATE: Security issues get debated away by majority
• Pure FAN-OUT: No blocking for security failures
• Hybrid: Security first, then parallel, then resolve conflicts

Example 2: Research Paper Writing

Problem: 3 agents (researcher, writer, fact-checker) produce literature review

Decision Process:

1. Initiative Type: Pull-based (agents work when ready) vs Push-based (coordinator assigns)
2. Quality vs Speed: Quality critical → redundancy needed
3. Decomposition: Topic can be partitioned by research area

Chosen Protocol:

researcher: Partitioned FAN-OUT across research areas
fact-checker: CRITIQUE-REFINE on each section  
writer: SUPERVISOR role synthesizing all inputs

Why not alternatives:

• All agents in single DEBATE: No clear roles, writer expertise wasted on fact-checking
• Sequential REQUEST/RESPONSE chain: Too slow, no parallel research
• Pure BLACKBOARD: No synthesis, just knowledge accumulation

Termination Logic:

Stop when:
- All research areas covered (completeness check)
- Fact-checker confidence > 0.85 on all sections
- Writer produces coherent synthesis
- Total tokens < budget OR time < deadline

Example 3: Dynamic Routing Decision

Problem: During execution, supervisor realizes 3 workers are overwhelmed, 1 worker is idle

Real-time Decision Tree:

Current state: 3 workers at 90% capacity, 1 worker at 10%
Options:
1. Rebalance work (migrate tasks to idle worker)
2. Add redundancy (parallel execution on critical path)  
3. Change topology (switch from star to mesh for peer delegation)

Decision factors:
├── Time remaining? < 25% → Option 2 (parallel, accept higher cost)
├── Budget remaining? < 50% → Option 1 (rebalance, optimize cost)  
└── Task dependencies? High coupling → Option 3 (mesh topology)

Execution: Supervisor detects state, broadcasts topology change message, workers update their delegation rules, work continues with new pattern

QUALITY GATES

• Termination Policy Defined: Every conversation has explicit max messages, time, and cost limits
• Cycle Detection Active: Delegation chains track agent history and prevent A→B→A loops
• Confidence Scores Present: All outputs include agent confidence (0.0-1.0) for quality assessment
• Progress Reporting Wired: Long-running tasks send periodic heartbeat messages to coordinator
• Context Handoff Validated: Each delegation includes token estimates and identifies droppable context sections
• Error Propagation Designed: System handles single agent failures without total conversation collapse
• Gather Policy Explicit: Fan-out operations specify wait conditions (all/majority/first/quorum)
• Role Diversity Enforced: Debate protocols assign distinct perspectives, not generic "discuss this topic"
• State Expiration Configured: Blackboard entries have TTL or confidence thresholds for automatic cleanup
• Topology Matches Task: Conversation structure aligns with problem decomposition (see decision tree)

NOT-FOR BOUNDARIES

This skill covers conversation design, NOT:

• Serialization formats (JSON schemas, message encoding) → Use agent-interchange-formats
• Infrastructure setup (message queues, service discovery) → Use agentic-infrastructure-2026
• Single-agent tool usage (function calling, chain-of-thought) → Use agentic-patterns
• Memory persistence (vector stores, episodic recall) → Use episodic-memory-algorithms
• Framework selection (AutoGen vs LangGraph vs CrewAI) → Use agentic-infrastructure-2026

Delegate to other skills when you encounter:

• Wire protocol design → agent-interchange-formats
• Performance optimization → agentic-infrastructure-2026
• Individual agent reasoning → agentic-patterns
• Long-term memory → episodic-memory-algorithms
• Tool integration → agentic-patterns