The field of AI is rapidly evolving, and the need for more sophisticated, collaborative, and flexible agent-based systems is growing. With this in mind, Semantic Kernel introduces a new multi-agent orchestration framework that enables developers to build, manage, and scale complex agent workflows with ease. This post explores the new orchestration patterns, their capabilities, and how you can leverage them in your own projects.

Why Multi-agent Orchestration?

Traditional single-agent systems are limited in their ability to handle complex, multi-faceted tasks. By orchestrating multiple agents, each with specialized skills or roles, we can create systems that are more robust, adaptive, and capable of solving real-world problems collaboratively. Multi-agent orchestration in Semantic Kernel provides a flexible foundation for building such systems, supporting a variety of coordination patterns.

Orchestration Patterns

1. Sequential Orchestration

In the sequential pattern, agents are organized in a pipeline. Each agent processes the task in turn, passing its output to the next agent in the sequence. This is ideal for workflows where each step builds upon the previous one, such as document review, data processing pipelines, or multi-stage reasoning.

Use case example

A document passes through a summarization agent, then a translation agent, and finally a quality assurance agent, each building on the previous output:

2. Concurrent Orchestration

The concurrent pattern enables multiple agents to work on the same task in parallel. Each agent processes the input independently, and their results are collected and aggregated. This approach is well-suited for scenarios where diverse perspectives or solutions are valuable, such as brainstorming, ensemble reasoning, or voting systems.

Use case example

Multiple agents generate different solutions to a problem, and their responses are collected for further analysis or selection:

3. Group Chat Orchestration

Group chat orchestration models a collaborative conversation among agents, optionally including a human participant. A group chat manager coordinates the flow, determining which agent should respond next and when to request human input. This pattern is powerful for simulating meetings, debates, or collaborative problem-solving sessions.

Use case example

Agents representing different departments discuss a business proposal, with a manager agent moderating the conversation and involving a human when needed:

4. Handoff Orchestration

Handoff orchestration allows agents to transfer control to one another based on the context or user request. Each agent can “handoff” the conversation to another agent with the appropriate expertise, ensuring that the right agent handles each part of the task. This is particularly useful in customer support, expert systems, or any scenario requiring dynamic delegation.

Use case example

A customer support agent handles a general inquiry, then hands off to a technical expert agent for troubleshooting, or to a billing agent if needed:

5. Magentic Orchestration

Magentic orchestration is designed based on the MagenticOne pattern invented by AutoGen. It is a flexible, general-purpose multi-agent pattern designed for complex, open-ended tasks that require dynamic collaboration. In this pattern, a dedicated Magentic manager coordinates a team of specialized agents, selecting which agent should act next based on the evolving context, task progress, and agent capabilities.

The Magentic manager maintains a shared context, tracks progress, and adapts the workflow in real time. This enables the system to break down complex problems, delegate subtasks, and iteratively refine solutions through agent collaboration. The orchestration is especially well-suited for scenarios where the solution path is not known in advance and may require multiple rounds of reasoning, research, and computation.

Use case example

A user requests a comprehensive report comparing the energy efficiency and CO₂ emissions of different machine learning models. The Magentic manager first assigns a research agent to gather relevant data, then delegates analysis and computation to a coder agent. The manager coordinates multiple rounds of research and computation, aggregates the findings, and produces a detailed, structured report as the final output.

*Image by AutoGen

Simplicity and Developer-friendly

All orchestration patterns share a unified interface for construction and invocation. No matter which orchestration you choose, you:

• Define your agents and their capabilities, see Semantic Kernel Agents.
• Create an orchestration by passing the agents (and, if needed, a manager).
• Optionally provide callbacks or transforms for custom input/output handling.
• Start a runtime and invoke the orchestration with a task.
• Await the result in a consistent, asynchronous manner.

This unified approach means you can easily switch between orchestration patterns, without learning new APIs or rewriting your agent logic. The framework abstracts away the complexity of agent communication, coordination, and result aggregation, letting you focus on your application’s goals.

Python

# Choose an orchestration pattern with your agents
orchestration = SequentialOrchestration(members=[agent_a, agent_b])
# or ConcurrentOrchestration, GroupChatOrchestration, HandoffOrchestration, MagenticOrchestration, ...

# Start the runtime
runtime = InProcessRuntime()
runtime.start()

# Invoke the orchestration
result = await orchestration.invoke(task="Your task here", runtime=runtime)

# Get the result
final_output = await result.get()

await runtime.stop_when_idle()

.Net

// Choose an orchestration pattern with your agents
SequentialOrchestration orchestration = new(agentA, agentB)
{
    LoggerFactory = this.LoggerFactory
};  // or ConcurrentOrchestration, GroupChatOrchestration, HandoffOrchestration, MagenticOrchestration, ...

// Start the runtime
InProcessRuntime runtime = new();
await runtime.StartAsync();

// Invoke the orchestration and get the result
OrchestrationResult<string> result = await orchestration.InvokeAsync(task, runtime);
string text = await result.GetValueAsync();

await runtime.RunUntilIdleAsync();

This consistency makes orchestrating multi-agent solutions easier than ever before—whether you are building simple pipelines or advanced, dynamic agent teams. Developers can rapidly prototype, experiment, and scale their multi-agent systems with minimal friction.

Getting Started

To help you get started, Semantic Kernel provides a set of samples demonstrating each orchestration pattern. These samples showcase how to define agents, configure orchestrations, and run collaborative workflows. You can find them via the following links:

• Python: semantic-kernel/python/samples/getting_started_with_agents/multi_agent_orchestration at main · microsoft/semantic-kernel
• .Net: semantic-kernel/dotnet/samples/GettingStartedWithAgents/Orchestration at main · microsoft/semantic-kernel

For more in-depth documentations, please visit the Microsoft Learn site for Semantic Kernel Multi-agent Orchestration.

Conclusion

Multi-agent orchestration in Semantic Kernel unlocks new possibilities for building intelligent, collaborative systems. Whether you need sequential processing, parallel brainstorming, group conversations, or dynamic handoffs, the new orchestration framework provides the tools you need to design and implement advanced agent workflows.

Explore the samples, experiment with different patterns, and start building your own multi-agent solutions today!

The Semantic Kernel team is dedicated to empowering developers by providing access to the latest advancements in the industry. We encourage you to leverage your creativity and build remarkable solutions with SK! Please reach out if you have any questions or feedback through our Semantic Kernel GitHub Discussion Channel. We look forward to hearing from you! We would also love your support, if you’ve enjoyed using Semantic Kernel, give us a star on GitHub.