Multi-agent collaboration

What Is Multi-agent Collaboration?

Key distinctions:

• vs. Single agent with tools: One agent calls tools sequentially; multi-agent means multiple reasoning loops happening in parallel or turn-based
• vs. Ensemble models: Ensembles combine predictions statistically; agents coordinate through explicit communication
• vs. Hierarchical agents: Can be flat (peers) or hierarchical (manager-worker), but collaboration implies information exchange, not just top-down commands

Why Collaboration Emerges: First Principles Derivation

Start with task complexity. A complex task $T$ requires capabilities $C = \{c_1, c_2, \ldots, c_n\}$ (e.g., web search, code execution, image analysis, domain reasoning).

Single-agent approach: One agent $A$ must have: $\text{Capability}(A) \supseteq C$

Problem: As $|C|$ grows, the agent's context window, training data requirements, and reasoning complexity explode. Prompts become unwieldy, and the agent loses focus.

Multi-agent approach: Partition capabilities: $C = C_1 \cup C_2 \cup \ldots \cup C_k \quad \text{where } C_i \cap C_j = \emptyset \text{ or minimal}$

Each agent $A_i$ specializes: $\text{Capability}(A_i) \supseteq C_i$.

Coordination cost: Agents must communicate. Let $M$ = messages exchanged. Total cost: $\text{Cost}_{\text{multi}} = \sum_{i=1}^k \text{Cost}(A_i) + \text{Cost}(M)$

When is multi-agent better? $\text{Cost}_{\text{multi}} < \text{Cost}_{\text{single}}$

This happens when:

1. Specialization gain: $\sum \text{Cost}(A_i) \ll \text{Cost}(A)$ because each $A_i$ has a simpler task, focused context, and better performance in its domain
2. Paralelization: Multiple $A_i$ can work simultaneously, reducing latency: $\text{Time}_{\text{multi}} \approx \max_i(\text{Time}(A_i)) + \text{Time}(M)$
3. Communication overhead is low: $\text{Cost}(M)$ doesn't dominate (well-defined interfaces, efficient messaging)

Derivation of emergent behavior: Each agent $A_i$ has a policy $\pi_i(s_i)$ conditioned on its local observation $s_i$. The joint behavior: $\pi_{\text{joint}}(s) = \prod_{i=1}^k \pi_i(s_i \mid \text{messages from others})$

Emergent behavior arises when the joint policy achieves outcomes that no individual $\pi_i$ could produce alone, through information sharing and action coordination.

Collaboration Patterns

1. Debate / Adversarial

• Structure: Two+ agents take opposing positions, argue, refine
• Why: Reduces confirmation bias, surfaces weak points in reasoning
• Example: Agent A proposes a solution, Agent B critiques, Agent C synthesizes
• Formula: Iterative refinement $\text{Output}_{t+1} = \text{Synthesize}(\text{Proposal}_t, \text{Critique}_t)$

2. Parallel with Aggregation

• Structure: Multiple agents solve the same problem independently, results are aggregated
• Why: Increases robustness (majority voting), explores diverse reasoning paths
• Example: Three agents generate code, take majority vote or best-of-N
• Formula: $\text{Final} = \text{Aggregate}(\{y_i\}_{i=1}^k) = \arg\max_y \sum_{i=1}^k \mathbb{1}[y_i = y]$

3. Sequential Pipeline

• Structure: Agent $A_1$ outputs to $A_2$ which outputs to $A_3$, etc.
• Why: Each agent specializes in one transformation stage
• Example: Researcher → Coder → Tester → Documenter
• Formula: $y = A_k(A_{k-1}(\ldots A_2(A_1(x)) \ldots))$ Risk: Error propagation—if $A_i$ fails, all downstream agents see corrupted input.

4. Dynamic Coordination (Manager-Worker)

• Structure: Manager agent delegates subtasks to worker agents based on current state
• Why: Adaptive—manager can re-plan as results come in
• Example: Manager breaks "build a web app" into frontend, backend, database subtasks, assigns to specialists
• Formula: Manager maintains a task queue $Q$ and assignment function: $\text{Assign}(t) = \arg\max_{A_i \in \text{Workers}} \text{Utility}(A_i, t)$

5. Peer-to-peer Negotiation

• Structure: Agents communicate directly, negotiate resources, reach consensus without central authority
• Why: Scales better than centralized (no bottleneck), but requires conflict resolution protocols
• Example: Multi-agent reinforcement learning for traffic control—each intersection agent negotiates signal timing with neighbors

Worked Example1: Software Development Team

Task: Build a Python web scraper for e-commerce product data.

Agents:

• Planner: Breaks task into subtasks
• Coder: Writes implementation code
• Tester: Writes and runs tests
• Reviewer: Reviews code quality, suggests improvements

Step-by-step:

1. Planner receives task:

   User: "Scrape Amazon product listings for laptops under $1000"
   

   Why this step? Need to decompose the vague task into concrete, implementable units.

   Planner outputs:

   Subtasks:
     1. Research Amazon's HTML structure for product listings
     2. Write scraper with requests + BeautifulSoup
     3. Handle pagination and rate limiting
     4. Parse product: name, price, rating
     5. Save to CSV6. Write unit tests

2. Coder receives subtask 2: Why this step? Specialist in implementation can focus on code quality without jugling planning.

   Coder writes:

   import requests
   from bs4 import BeautifulSoup
   def scrape_amazon(url, max_price=1000):
       response = requests.get(url, headers={'User-Agent': '...'})
       soup = BeautifulSoup(response.content, 'html.parser')
       products = []
       for item in soup.select('.s-result-item'):
           price = parse_price(item)
           if price and price <= max_price:
               products.append({...})
       return products

3. Tester receives code: Why this step? Separate agent ensures tests aren't biased by implementation details. Tester writes:

   def test_scrape_amazon():
       mock_html = '<div class="s-result-item">...</div>'
       # Mock requests, verify parsing
       assert len(scrape_amazon(mock_url)) > 0

   Runs tests, reports: "Parse function fails on missing price field."

4. Reviewer receives code + test results: Why this step? Fresh eyes catch issues the coder and tester missed (e.g., security, maintainability).

   Reviewer suggests:

   • "Add error handling for network failures"
   • "Use a delay between requests to avoid rate limiting"

5. Coder iterates based on feedback, Tester re-runs, Reviewer approves.

Emergent outcome: Higher quality code than a single agent could produce, because each agent brought specialized scrutiny.

Worked Example 2: Research Paper Analysis

Task: "Summarize key contributions of 5 recent papers on multi-agent RL."

Agents:

• Searcher: Finds relevant papers (tool: web search)
• Reader (×5): Each reads one paper in depth
• Synthesizer: Combines findings into coherent summary

Step-by-step:

1. Searcher queries arXiv, returns 5 paper PDFs. Why parallel readers? Reading 5 papers is slow sequentially; parallel agents reduce latency from 50minutes to 10 minutes.

2. Readers (in parallel):

   • Reader1: "Paper A introduces a new credit assignment method for cooperative games..."
   • Reader2: "Paper B applies graph neural networks to agent communication..."
   • ...

3. Synthesizer receives 5 summaries: Why a separate synthesizer? Readers are biased toward their own paper; synthesizer has the full context to identify common themes, contradictions, and gaps.

   Synthesizer outputs:

   **Common theme**: All papers struggle with non-stationarity (agents' policies change, violating ID assumption).
   **Novel contributions**:
     - Paper A: Centralized training, decentralized execution (CTDE)
     - Paper B: Communication via learned embedings
   **Contradictions**: Paper C claims full decentralization is necessary, but Paper D shows CTDE outperforms in practice.
   

Emergent outcome: Nuanced synthesis that no single agent could produce without reading all papers, which would exceed context limits.

Communication Mechanisms

Agents communicate via messages $m$. The design space:

1. Natural language: Flexible, interpretable, but ambiguous $m = \text{"Agent A, please analyze the data in file X"}$ Pro: LMs understand directly. Con: Parsing failures, verbose.

2. Structured (JSON/YAML): Explicit schema, machine-parsable

   {
     "from": "AgentA",
     "to": "AgentB",
     "action": "analyze_data",
     "params": {"file": "X", "method": "regression"}
   }

   Pro: Reliable, testable. Con: Requires upfront schema design.

3. Shared memory: Agents read/write to a common state (e.g., a database, a shared document) $\text{Memory}_{t+1} = \text{Memory}_t \cup \{\text{update from } A_i\}$ Pro: Scales to many agents (no N² message passing). Con: Concurrency issues, requires locking.

4. Blackboard architecture: Central "blackboard" where agents post partial solutions, others read and build on them Why it works: Decouples agents—no need to know who else is working, just check the blackboard.

Latency analysis: If each agent takes $T$ seconds to reason and messages take $\Delta$ seconds:

• Sequential pipeline: Total time $= kT + (k-1)\Delta$
• Parallel with aggregation: Total time $= T + \Delta$ (all agents run simultaneously)
• Dynamic coordination: Total time $\approx T_{\text{manager}} + \max_i(T_{\text{worker}_i}) + n\Delta$ (n rounds of feedback)

Common Mistakes

Active Recall Flashcards

#flashcards/ai-ml

What is multi-agent collaboration? :: Multiple autonomous agents with specialized capabilities working together by exchanging messages and coordinating actions to solve complex problems no single agent could handle.

Connections

• 6.2.01-What-are-AI-agents: Foundation—multi-agent is multiple instances of agents
• 6.2.02-Perception-action-cycle: Each agent in a multi-agent system runs its own perception-action loop
• 6.2.05-Agent-tool-use: Multi-agent can be viewed as agents using "other agents" as tools
• 6.3.01-Prompt-engineering-for-agents: Each agent needs effective prompts; manager agents need meta-prompting
• Ensemble-methods: Parallel multi-agent with aggregation is similar to model ensembles but with explicit reasoning
• Distributed-systems: Multi-agent borows concepts from distributed computing—consensus, coordination, fault tolerance
• Game-theory: Peer-to-peer negotiation uses game-theoretic principles for equilibrium
• Reinforcement-learning: Multi-agent RL studies how agents learn policies in the presence of other learning agents

Last updated: 2026-07-01 | Next: 6.2.07-Agent-memory-systems

Concept Map

Hinglish (regional understanding)