Multi-Agent Architectures, Orchestration Frameworks, and Enterprise Deployments
Research current as of: January 2026
The evolution from single-agent systems to multi-agent architectures represents one of the most significant shifts in AI agent development. Where single agents excel at focused, well-defined tasks, multi-agent systems unlock the ability to tackle complex, multi-faceted problems that require diverse expertise, parallel processing, and sophisticated coordination.1AcademicImproving Factuality and Reasoning through Multiagent DebateView Paper
As Gartner reported, the 1,445% surge in multi-agent system inquiries from Q1 2024 to Q2 2025 signals a fundamental transformation in how AI systems are designed. By 2028, Gartner predicts that 15% of daily business decisions will be automated by AI agents, with 33% of enterprise software depending on agentic AI.
If 2025 was the year of AI agents, 2026 is emerging as the year of multi-agent systems, as the infrastructure needed for coordinated agents has finally matured. This section explores the architectures, frameworks, patterns, and real-world implementations that are driving this transformation.
Multi-agent systems can be organized using several fundamental architectural patterns, each with distinct characteristics, advantages, and optimal use cases.
A hierarchical architecture where a central orchestrator receives user requests, decomposes them into subtasks, delegates work to specialized agents, monitors progress, validates outputs, and synthesizes a final unified response.
Well-defined workflows, compliance-heavy environments, enterprise applications requiring strict governance and audit trails.
Agents coordinate directly with each other without a central controller. Each agent can initiate communication, request assistance, or delegate tasks to peers based on their capabilities and current state.
Dynamic environments, systems requiring high availability, distributed computing scenarios, research and exploration tasks.
Multiple layers of agents with different levels of authority and abstraction. Higher-level agents handle planning and oversight, while lower-level agents execute operational tasks. Each layer coordinates within its scope.2AcademicMetaGPT: Meta Programming for A Multi-Agent Collaborative FrameworkView Paper
Large-scale enterprise systems, complex workflows with natural hierarchies, organizations with multiple departments or teams.
Agents from different departments or organizations collaborate without sharing raw data. Each organization maintains its own agent systems, which communicate through standardized protocols while preserving data sovereignty.
Regulated industries (BFSI, healthcare), cross-organizational workflows, privacy-sensitive applications.
Beyond architectural structures, specific coordination patterns define how agents collaborate to accomplish tasks. These patterns have emerged as standard building blocks for multi-agent systems.3AcademicAgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent BehaviorsView Paper
A central orchestrator breaks tasks down, assigns work to specialized workers, then synthesizes results. This pattern powers retrieval-augmented generation (RAG), coding agents, and sophisticated multimodal research.
Use Cases: Document analysis, code review, parallel research, data processing pipelines
Example: A research agent splits a complex query into subtopics, assigns each to specialized research workers, then aggregates findings into a comprehensive report.
An initial LLM acts as a router, classifying user input and directing it to the most appropriate specialized task or agent. This implements separation of concerns and allows optimizing individual downstream tasks in isolation.
Use Cases: Customer support triage, multi-intent handling, tiered LLM usage (routing simple queries to cheaper models)
Example: A customer service system routes billing questions to a billing specialist agent, technical issues to a support agent, and product questions to a product specialist.
Agents collaborate in a continuous loop: one generates solutions, the other evaluates and suggests improvements. The cycle continues until quality thresholds are met or maximum iterations reached.9IndustryBuilding Effective AgentsView Guide
Use Cases: Content generation, code optimization, iterative refinement tasks
Example: A writing agent generates content while an evaluation agent scores quality and provides feedback, iterating until the content meets standards.
Splitting a large task into independent sub-tasks for concurrent execution by multiple agents or LLMs. Drastically reduces time to resolution and improves consensus accuracy.7AcademicTree of Thoughts: Deliberate Problem Solving with Large Language ModelsView Paper
Use Cases: Code review, candidate evaluation, A/B testing, building guardrails
Example: A code review system assigns different files to different reviewer agents simultaneously, then aggregates feedback.
Agents share information through a common knowledge base (blackboard). Agents read from and write to the blackboard asynchronously, enabling loose coupling.3AcademicAgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent BehaviorsView Paper
Use Cases: Collaborative problem-solving, knowledge aggregation, complex reasoning tasks
Tasks are announced, and agents bid based on their capabilities and current load. The system assigns tasks to the most appropriate agents.
Use Cases: Dynamic resource allocation, load balancing, market-based coordination
Effective multi-agent systems depend on standardized communication protocols that enable agents to discover each other, exchange information, and coordinate actions.
Announced: May 2024
Purpose: Standardized interface for accessing tools and resources
Key Features:
Announced: May 2025
Purpose: Structured inter-agent communication
Key Features:
Developed by: IBM
Purpose: Standardize agent communication, task delegation, and workflow orchestration
Key Features:
Modern multi-agent systems often employ a protocol stacking approach, layering multiple communication protocols to address different aspects:
The multi-agent framework landscape evolved dramatically in 2025, with several platforms reaching production maturity. Here's a comprehensive comparison of the leading frameworks.
| Framework | Architecture | Key Strengths | Performance | Best For |
|---|---|---|---|---|
| LangGraph | Graph-based state machines | Fastest framework, flexible control flows, built-in persistence, human-in-the-loop | Lowest latency across all tasks (2026 benchmarks) | Production systems, complex workflows, multi-agent orchestration |
| CrewAI | Role-based collaboration | 5.76x faster than LangGraph in some cases, dual Crews/Flows architecture, extensive memory systems | Optimized for speed and minimal resources | Finance, research, customer support, rapid prototyping |
| Microsoft Agent Framework | Event-driven + data flow | Merger of AutoGen + Semantic Kernel, enterprise features, strong observability | Enterprise-grade scalability | Microsoft ecosystem, enterprise deployments, Azure integration |
| n8n | Visual workflow automation | Low-code, visual canvas, business automation integration | Best for visual builders | Business automation, non-technical teams, hybrid workflows |
| Salesforce Agentforce | Integrated enterprise platform | CRM integration, governance, Command Center, 12,000 customers | 46% case deflection, 84% faster resolution | Salesforce customers, CRM-centric workflows |
LangGraph and LangChain both reached v1.0 in November 2024, marking commitment to stability with no breaking changes until 2.0.10IndustryMulti-Agent Architectures DocumentationView Docs
LangGraph uses a graph-based approach where each agent is represented as a node that maintains its own state, connected through a directed graph enabling conditional logic, multi-team coordination, and hierarchical control.
According to 2026 benchmarks, LangGraph is the fastest framework with the lowest latency values across all tasks compared to CrewAI, OpenAI Swarm, and standard LangChain.
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator
class AgentState(TypedDict):
messages: Annotated[list, operator.add]
current_agent: str
task_result: dict
# Define agent nodes
def research_agent(state):
# Perform research
return {"task_result": {"research": "completed"}}
def analysis_agent(state):
# Analyze results
return {"task_result": {"analysis": "completed"}}
def writing_agent(state):
# Generate final output
return {"task_result": {"writing": "completed"}}
# Build the graph
workflow = StateGraph(AgentState)
# Add nodes
workflow.add_node("research", research_agent)
workflow.add_node("analysis", analysis_agent)
workflow.add_node("writing", writing_agent)
# Define edges
workflow.add_edge("research", "analysis")
workflow.add_edge("analysis", "writing")
workflow.add_edge("writing", END)
# Set entry point
workflow.set_entry_point("research")
# Compile
app = workflow.compile()
# Execute
result = app.invoke({"messages": [], "current_agent": "research"})CrewAI is an open-source Python framework for building collaborative AI agent teams with specialized roles, designed to mimic real-world organizational structures.11IndustryCrewAI Documentation - Multi-Agent SystemsView Docs
Independent of LangChain, built from scratch, optimized for speed. Demonstrates 5.76x faster execution than LangGraph in certain cases.
from crewai import Agent, Task, Crew, Process
# Define agents with roles
researcher = Agent(
role='Research Specialist',
goal='Gather comprehensive information on the topic',
backstory='Expert researcher with deep analytical skills',
tools=[search_tool, scrape_tool],
memory=True
)
analyst = Agent(
role='Data Analyst',
goal='Analyze research findings and extract insights',
backstory='Experienced analyst with pattern recognition expertise',
tools=[analysis_tool],
memory=True
)
writer = Agent(
role='Content Writer',
goal='Create compelling content from analysis',
backstory='Professional writer skilled at translating data to narrative',
tools=[writing_tool],
memory=True
)
# Define tasks
research_task = Task(
description='Research recent developments in multi-agent AI systems',
expected_output='Comprehensive research report with sources',
agent=researcher
)
analysis_task = Task(
description='Analyze research findings for key trends',
expected_output='Analysis with identified patterns and insights',
agent=analyst
)
writing_task = Task(
description='Create article from analysis',
expected_output='Publication-ready article',
agent=writer
)
# Create crew
crew = Crew(
agents=[researcher, analyst, writer],
tasks=[research_task, analysis_task, writing_task],
process=Process.sequential,
memory=True,
verbose=True
)
# Execute
result = crew.kickoff()AutoGen and Semantic Kernel merged into a single unified framework under the name Microsoft Agent Framework, combining AutoGen's simple abstractions for multi-agent patterns with Semantic Kernel's enterprise-grade features.5AcademicAutoGen: Enabling Next-Gen LLM Applications via Multi-Agent ConversationView Paper12IndustryAI Agent Orchestration PatternsView Docs
Sequential, concurrent, hand-off, and Magentic patterns for coordinating multiple AI agents.
Before the merger, AutoGen v0.4 adopted an asynchronous, event-driven architecture enabling:
Migration requires rethinking approach from event-driven to data-flow based architectures, though straightforward for those familiar with AutoGen concepts.
n8n is an open-source workflow automation tool that has evolved into a powerful platform for visual multi-agent orchestration, making AI agents accessible to non-technical teams.
The world's first platform designed to connect humans and AI agents in one trusted system, marking the arrival of the "Agentic Enterprise."
As agents collaborate, conflicts inevitably arise from competing priorities, contradictory information, or divergent reasoning. Effective conflict resolution is critical for reliable multi-agent deployments.6AcademicCAMEL: Communicative Agents for Mind ExplorationView Paper
Systematic approaches for reconciling contradictions and establishing shared understanding. Modern deployments demonstrate substantial processing capabilities and high conflict resolution accuracy rates across various deployment scenarios.
Democratic mechanisms for resolving information conflicts by aggregating agents' preferences or beliefs. Particularly effective when multiple agents evaluate the same evidence.1AcademicImproving Factuality and Reasoning through Multiagent DebateView Paper
Built-in frameworks allowing agents with competing priorities to negotiate solutions using rules, escalation policies, or optimization algorithms.
When conflicts exceed automated resolution capabilities, systems escalate to human operators. Industry data suggests 3-7% of decisions may require human intervention initially, decreasing as systems mature.
Organizations successfully deploying multi-agent systems follow established patterns for architecture, operations, and governance.
Real-world implementations demonstrate the transformative impact of multi-agent systems across industries.
Platform: Microsoft Multi-Agent Orchestration
Scale: 35,000 bankers
Bankers needed quick access to 1,700 complex procedures and compliance requirements. Manual search took 10+ minutes per query, creating bottlenecks and compliance risks.
Multi-agent system with specialized agents for procedures, compliance, customer history, and product information. Central orchestrator routes queries to appropriate agents and synthesizes responses.
Platform: Custom multi-agent system with OpenAI
Focus: Payment optimization, fraud detection, recovery operations
Multiple specialized agents handle payment optimization, fraud detection, and recovery operations simultaneously, collaborating through the Agentic Commerce Protocol (ACP) codeveloped with OpenAI.
Stripe and OpenAI codeveloped ACP to handle fraud detection in AI agent-driven commerce, addressing challenges like AI agents being misflagged as fraudulent or manipulated by bad actors.
Platform: Custom multi-agent platform built on existing messaging infrastructure
First Implementation: Hiring Assistant (global availability)
LinkedIn extended its generative AI application platform to support multi-agent systems by repurposing existing messaging infrastructure as an orchestration layer, avoiding the need to build new coordination technology from scratch.
Platform: Salesforce Agentforce
Industry: IT Services
Multi-agent system for customer service automation with agents specializing in case triage, technical support, knowledge retrieval, and escalation management.
Platform: Salesforce Agentforce 360
Multi-agent customer support system handling common queries automatically while escalating complex issues to human agents with full context.
Goldman Sachs, JP Morgan, and HSBC use AI agents for compliance and financial analysis, with early data showing one agent replacing the work of 50 analysts while improving accuracy.
Veeva Systems announced comprehensive rollout of AI Agents across all applications, beginning December 2025 for commercial applications and expanding through 2026 for R&D and quality.
Major cloud providers (AWS, Azure, Google Cloud) offering native multi-agent orchestration capabilities with production-ready governance and monitoring.
Business leaders demonstrate unwavering commitment: 67% say they will maintain spending even if a recession occurs in the next 12 months, with a projected $124 million to be deployed over the coming year per organization.
Leaders have moved beyond initial deployments and are professionalizing and preparing to scale agent systems—readying data, investing in infrastructure, and building governance and observability to run multi-agent systems reliably.
Recent framework updates signal maturation:
from langgraph.graph import StateGraph, END
from typing import TypedDict, Literal
import operator
from typing import Annotated
class SupervisorState(TypedDict):
messages: Annotated[list, operator.add]
next: str
def create_supervisor_chain(members: list[str]):
"""Create supervisor that routes to appropriate agent"""
system_prompt = f"""You are a supervisor managing these workers: {members}.
Given user request, determine which worker should act next.
Each worker will perform a task and respond with results.
When finished, respond with FINISH."""
# Supervisor decides next agent
def supervisor(state):
# Logic to determine next agent based on state
# Returns name of next agent or "FINISH"
return {"next": determine_next_agent(state)}
return supervisor
# Define worker agents
def research_agent(state):
"""Performs research tasks"""
# Implementation
return {"messages": ["Research completed"]}
def analysis_agent(state):
"""Performs analysis tasks"""
# Implementation
return {"messages": ["Analysis completed"]}
def writer_agent(state):
"""Generates content"""
# Implementation
return {"messages": ["Content written"]}
# Build supervisor workflow
workflow = StateGraph(SupervisorState)
# Add supervisor and workers
workflow.add_node("supervisor", create_supervisor_chain(
["research", "analysis", "writer"]
))
workflow.add_node("research", research_agent)
workflow.add_node("analysis", analysis_agent)
workflow.add_node("writer", writer_agent)
# Conditional routing based on supervisor decision
workflow.add_conditional_edges(
"supervisor",
lambda x: x["next"],
{
"research": "research",
"analysis": "analysis",
"writer": "writer",
"FINISH": END
}
)
# Workers report back to supervisor
workflow.add_edge("research", "supervisor")
workflow.add_edge("analysis", "supervisor")
workflow.add_edge("writer", "supervisor")
workflow.set_entry_point("supervisor")
app = workflow.compile()from typing import Protocol, List, Dict, Any
class Agent(Protocol):
"""Base protocol for agents"""
def can_handle(self, task: Dict[str, Any]) -> bool:
"""Check if agent can handle the task"""
...
def execute(self, task: Dict[str, Any]) -> Dict[str, Any]:
"""Execute the task"""
...
def handoff(self, result: Dict[str, Any], agents: List['Agent']) -> 'Agent':
"""Determine which agent should handle next"""
...
class ResearchAgent:
name = "research"
def can_handle(self, task):
return task.get("type") == "research"
def execute(self, task):
# Perform research
return {
"status": "completed",
"data": "research findings",
"next_type": "analysis"
}
def handoff(self, result, agents):
# Find analyst agent
for agent in agents:
if hasattr(agent, 'name') and agent.name == "analysis":
return agent
return None
class AnalysisAgent:
name = "analysis"
def can_handle(self, task):
return task.get("type") == "analysis"
def execute(self, task):
# Perform analysis
return {
"status": "completed",
"data": "analysis results",
"next_type": "writing"
}
def handoff(self, result, agents):
for agent in agents:
if hasattr(agent, 'name') and agent.name == "writing":
return agent
return None
class WritingAgent:
name = "writing"
def can_handle(self, task):
return task.get("type") == "writing"
def execute(self, task):
# Generate content
return {
"status": "completed",
"data": "final content",
"next_type": None
}
def handoff(self, result, agents):
return None # End of workflow
# Multi-agent coordinator
class PeerToPeerCoordinator:
def __init__(self, agents: List[Agent]):
self.agents = agents
def execute_workflow(self, initial_task: Dict[str, Any]):
current_task = initial_task
current_agent = None
# Find first agent that can handle the task
for agent in self.agents:
if agent.can_handle(current_task):
current_agent = agent
break
results = []
while current_agent:
# Execute with current agent
result = current_agent.execute(current_task)
results.append(result)
# Determine next agent through handoff
next_agent = current_agent.handoff(result, self.agents)
if next_agent:
# Prepare task for next agent
current_task = {
"type": result.get("next_type"),
"data": result.get("data")
}
current_agent = next_agent
else:
current_agent = None
return results
# Usage
agents = [ResearchAgent(), AnalysisAgent(), WritingAgent()]
coordinator = PeerToPeerCoordinator(agents)
results = coordinator.execute_workflow({
"type": "research",
"query": "Multi-agent AI systems"
})from typing import Dict, Any, Callable
from enum import Enum
class AgentType(Enum):
BILLING = "billing"
TECHNICAL = "technical"
PRODUCT = "product"
GENERAL = "general"
class RouterAgent:
"""Routes requests to specialized agents based on classification"""
def __init__(self, specialized_agents: Dict[AgentType, Callable]):
self.agents = specialized_agents
self.classifier = self._create_classifier()
def _create_classifier(self):
"""Create LLM-based classifier"""
# In practice, this would use an LLM
def classify(query: str) -> AgentType:
# Simplified classification logic
query_lower = query.lower()
if any(word in query_lower for word in ["bill", "payment", "invoice"]):
return AgentType.BILLING
elif any(word in query_lower for word in ["error", "bug", "not working"]):
return AgentType.TECHNICAL
elif any(word in query_lower for word in ["feature", "product", "upgrade"]):
return AgentType.PRODUCT
else:
return AgentType.GENERAL
return classify
def route_and_execute(self, query: str) -> Dict[str, Any]:
"""Route query to appropriate agent and execute"""
# Classify the query
agent_type = self.classifier(query)
# Get the appropriate agent
agent = self.agents.get(agent_type)
if not agent:
return {
"error": f"No agent found for type {agent_type}",
"query": query
}
# Execute with the specialized agent
return {
"agent_type": agent_type.value,
"result": agent(query),
"query": query
}
# Define specialized agents
def billing_agent(query: str) -> str:
return f"Billing Agent: Processing billing query: {query}"
def technical_agent(query: str) -> str:
return f"Technical Agent: Troubleshooting: {query}"
def product_agent(query: str) -> str:
return f"Product Agent: Providing product information: {query}"
def general_agent(query: str) -> str:
return f"General Agent: Handling general inquiry: {query}"
# Create router
router = RouterAgent({
AgentType.BILLING: billing_agent,
AgentType.TECHNICAL: technical_agent,
AgentType.PRODUCT: product_agent,
AgentType.GENERAL: general_agent
})
# Route queries
queries = [
"I have a question about my invoice",
"The app keeps crashing",
"What features are in the premium plan?",
"Can you help me?"
]
for query in queries:
result = router.route_and_execute(query)
print(f"Query: {query}")
print(f"Routed to: {result['agent_type']}")
print(f"Result: {result['result']}\n")Practical Claude Code patterns for multi-agent orchestration. These examples demonstrate the Task tool for subagent delegation, parallel execution, and result aggregation based on AutoGen-style coordination patterns.5AcademicAutoGen: Multi-Agent ConversationView Paper
The main agent delegates specialized work to subagents via the Task tool, implementing the coordinator-worker pattern from multi-agent research.2AcademicMetaGPT: Multi-Agent Collaborative FrameworkView Paper
from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition
# Define specialized subagents
researcher = AgentDefinition(
description="Research specialist for gathering information.",
prompt="Gather comprehensive information on the topic. Cite sources.",
tools=["Read", "Grep", "Glob"]
)
analyst = AgentDefinition(
description="Data analyst for synthesizing findings.",
prompt="Analyze data and extract actionable insights.",
tools=["Read", "Bash"] # Can run analysis scripts
)
writer = AgentDefinition(
description="Technical writer for documentation.",
prompt="Write clear, well-structured documentation.",
tools=["Read", "Write"]
)
# Orchestrator delegates via Task tool
async for message in query(
prompt="""Create a technical report on the auth system:
1. Use researcher to gather information about current auth implementation
2. Use analyst to identify security patterns and issues
3. Use writer to create the final report document""",
options=ClaudeAgentOptions(
allowed_tools=["Task"], # Orchestrator only delegates
agents={
"researcher": researcher,
"analyst": analyst,
"writer": writer
}
)
):
if hasattr(message, "result"):
print(message.result)Run multiple independent agent queries in parallel for faster execution, following the distributed pattern discussed in multi-agent architectures.
import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions
async def parallel_analysis():
"""Run multiple analyses in parallel."""
# Define independent tasks
tasks = [
query(
prompt="Analyze security vulnerabilities in src/auth/",
options=ClaudeAgentOptions(allowed_tools=["Read", "Grep"])
),
query(
prompt="Analyze performance bottlenecks in src/api/",
options=ClaudeAgentOptions(allowed_tools=["Read", "Grep"])
),
query(
prompt="Check test coverage in tests/",
options=ClaudeAgentOptions(allowed_tools=["Read", "Bash"])
)
]
# Execute in parallel using asyncio.gather
results = await asyncio.gather(*[
collect_results(task) for task in tasks
])
return results
async def collect_results(query_gen):
result = None
async for msg in query_gen:
if hasattr(msg, "result"):
result = msg.result
return result
asyncio.run(parallel_analysis())import { query } from "@anthropic-ai/claude-agent-sdk";
// Helper to collect results from a query stream
async function collectResult(queryStream: AsyncIterable<any>) {
let result = null;
for await (const msg of queryStream) {
if ("result" in msg) result = msg.result;
}
return result;
}
// Run analyses in parallel
const results = await Promise.all([
collectResult(query({ prompt: "Analyze security in src/auth/", options: { allowedTools: ["Read", "Grep"] } })),
collectResult(query({ prompt: "Analyze performance in src/api/", options: { allowedTools: ["Read", "Grep"] } })),
collectResult(query({ prompt: "Check test coverage", options: { allowedTools: ["Read", "Bash"] } }))
]);
console.log("Security:", results[0]);
console.log("Performance:", results[1]);
console.log("Coverage:", results[2]);Combine outputs from multiple agents into a unified result, implementing the collaborative peer pattern described in the multi-agent debate research.1AcademicImproving Factuality through Multiagent DebateView Paper
from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition
# Multiple reviewers provide different perspectives
reviewers = {
"security-reviewer": AgentDefinition(
description="Security-focused code reviewer.",
prompt="Focus on security vulnerabilities and best practices.",
tools=["Read", "Grep"]
),
"perf-reviewer": AgentDefinition(
description="Performance-focused code reviewer.",
prompt="Focus on performance bottlenecks and optimization.",
tools=["Read", "Grep"]
),
"maintainability-reviewer": AgentDefinition(
description="Code quality and maintainability reviewer.",
prompt="Focus on code clarity, patterns, and technical debt.",
tools=["Read", "Grep"]
)
}
# Aggregator synthesizes all reviews
async for message in query(
prompt="""Review src/payment/ from multiple perspectives:
1. Get security review from security-reviewer
2. Get performance review from perf-reviewer
3. Get maintainability review from maintainability-reviewer
4. Synthesize into a unified code review report with prioritized recommendations""",
options=ClaudeAgentOptions(
allowed_tools=["Read", "Write", "Task"],
agents=reviewers
)
):
if hasattr(message, "result"):
print(message.result)GSD workflows demonstrate multi-agent coordination through plan execution with specialized phase agents.9IndustryBuilding Effective AgentsView Guide
# GSD orchestrates multiple specialized execution agents:
# 1. Planning agent (creates PLAN.md files)
# 2. Execution agent (implements tasks from plans)
# 3. Verification agent (validates completed work)
# Initialize multi-phase project
claude "/gsd:initialize"
# Each phase spawns independent execution agents
# Coordination happens via file-based state (STATE.md, SUMMARY.md)GSD implements wave-based parallel execution where plans are grouped by dependency and executed in parallel within waves. This pattern maps to the coordination research from Wu et al. on multi-agent conversation frameworks.5
Plans specify their wave number in frontmatter (wave: N). The execute-phase orchestrator groups plans by wave and spawns all Wave N plans in parallel. Wave N+1 only begins after all Wave N plans complete. This maximizes parallelism while respecting dependencies.
---
phase: 03-implementation
plan: 02
wave: 1 # Execute in Wave 1 (parallel)
depends_on: [] # No dependencies
autonomous: true # No human checkpoints
---
# Plan 03-03 depends on 03-01:
---
phase: 03-implementation
plan: 03
wave: 2 # Execute in Wave 2 (after Wave 1)
depends_on: ["03-01"] # Requires 03-01 artifacts
autonomous: false # Has human verification checkpoint
---Research current as of: January 2026