Principle:Microsoft Agent framework Concurrent Orchestration
| Knowledge Sources | |
|---|---|
| Domains | Agent_Architecture, Multi_Agent_Systems |
| Last Updated | 2026-02-11 15:00 GMT |
Overview
The Concurrent Orchestration principle describes a multi-agent execution pattern in which all participating agents receive the same input prompt simultaneously, run in parallel, and have their results aggregated into a unified output. This fan-out/fan-in dispatch model enables multi-perspective analysis by collecting independent responses from diverse agents and combining them through a configurable aggregation step.
Description
In many multi-agent scenarios, a single prompt benefits from being evaluated by multiple specialized agents rather than being routed to just one. The Concurrent Orchestration pattern addresses this by implementing a three-phase workflow:
Phase 1: Fan-Out Dispatch
The ConcurrentBuilder constructs a workflow where a single input prompt is broadcast to all registered participants simultaneously. Each participant -- whether a full agent (SupportsAgentRun) or a lightweight executor (Executor) -- receives an identical copy of the input. There is no sequencing or dependency between participants at this stage; all are dispatched concurrently.
Phase 2: Parallel Execution
All participants execute independently and in parallel. Each participant processes the input according to its own instructions, tools, and configuration. Because participants do not share state during execution, there is no contention or coordination overhead between them. This maximizes throughput and minimizes end-to-end latency, as the total wall-clock time is bounded by the slowest participant rather than the sum of all participants.
Phase 3: Fan-In Aggregation
Once all participants have completed, their individual results are collected into a list of AgentExecutorResponse objects. An aggregator function then combines these results into the final output. The aggregator can be:
- An
Executor(e.g., an LLM-based agent that synthesizes multiple perspectives into a coherent summary). - A simple callable that receives the list of responses and produces a merged result.
- A context-aware callable that also receives the
WorkflowContextfor access to workflow-level metadata.
If no aggregator is specified, the workflow returns the raw list of participant responses.
Design Properties
| Property | Value |
|---|---|
| Dispatch Model | Fan-out: all participants receive the same prompt simultaneously |
| Execution Model | Fully parallel with no inter-participant dependencies |
| Aggregation Model | Fan-in: configurable aggregator combines all results |
| Latency Bound | Wall-clock time equals the slowest participant (not the sum) |
| State Isolation | Participants do not share mutable state during execution |
Theoretical Basis
The Concurrent Orchestration pattern draws from established principles in distributed systems and collective intelligence:
1. Embarrassingly parallel workloads: When agents are independent and share no mutable state, the problem is trivially parallelizable. The concurrent pattern exploits this by dispatching all participants simultaneously without synchronization barriers.
2. Ensemble methods: In machine learning, ensemble approaches (bagging, boosting, stacking) combine multiple models to produce outputs that are more robust than any individual model. Similarly, collecting responses from multiple specialized agents and aggregating them can yield analysis that is more comprehensive and less biased than a single-agent approach.
3. Map-reduce decomposition: The fan-out phase maps the input across all participants, while the fan-in phase reduces their outputs through aggregation. This mirrors the map-reduce paradigm used in distributed data processing.
4. Multi-perspective reasoning: Research in collaborative AI demonstrates that prompting a question from diverse viewpoints -- such as a researcher, a marketer, and a legal analyst -- surfaces considerations that a single perspective would miss.
Usage
Use the Concurrent Orchestration pattern when:
- Multiple viewpoints are needed on the same input (e.g., analyzing a product launch from technical, marketing, and legal angles).
- Independent evaluations must be collected and compared (e.g., multiple reviewers grading a submission).
- Latency is a concern and sequential processing through multiple agents would be too slow.
- Robustness is desired by combining diverse agent outputs to reduce the risk of any single agent's blind spots.
Example
from agent_framework.orchestrations import ConcurrentBuilder
# Define specialized agents
researcher = ... # Agent focused on technical feasibility
marketer = ... # Agent focused on market positioning
legal = ... # Agent focused on regulatory compliance
# Build a concurrent workflow with all three perspectives
workflow = ConcurrentBuilder(participants=[researcher, marketer, legal]).build()
# All three agents process the same prompt in parallel
result = await workflow.run("Launch plan for new product")