Microsoft Agent Framework、オーケストレーションパターンがバージョン1.0に到達

Python’s agent-framework-orchestrations package is now 1.0.0. That puts Microsoft Agent Framework’s orchestration layer at 1.0 across Python and .NET.

Sequential, concurrent, group chat, handoff, and magentic orchestration are now stable in both SDKs. You can pick the coordination pattern that fits your problem instead of choosing around SDK maturity.

Magentic is the best example of why that matters. It is the least hand-wired pattern: you give it a goal, a manager, and a set of specialists, then the manager decides how the team should work.

At the workflow layer, Agent Framework lets you build the graph yourself. Executors do the work, edges route messages, and the workflow emits events as it runs. Those are the low-level primitives. The workflow docs cover that model in more depth.

The orchestration builders sit one level above those primitives. They use the same workflow model internally and return ordinary workflows you can run, stream, and compose.

That matters because coordination is the part many multi-agent apps otherwise reimplement. You choose the next agent, carry state between turns, detect stalls, and decide when the work is finished.

Magentic moves that coordination into the orchestration. A manager agent turns the task into a plan, assigns work to specialists, checks progress after each round, and revises the plan when the team stops moving.

The code below uses MagenticBuilder to create a workflow without wiring that graph by hand. You still choose the participants and guardrails, but the manager owns the round-by-round coordination.

import os

from agent_framework import Agent, AgentResponseUpdate

from agent_framework.foundry import FoundryChatClient

from agent_framework.orchestrations import MagenticBuilder

from azure.identity import AzureCliCredential

client = FoundryChatClient(

project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],

model=os.environ["FOUNDRY_MODEL"],

credential=AzureCliCredential(),

)

researcher = Agent(

name="Researcher",

description="Finds and gathers information",

instructions="You research. You do not do quantitative analysis.",

client=client,

)

coder = Agent(

name="Coder",

description="Writes and runs code to analyze data",

instructions="You answer quantitative questions by writing and running code.",

client=client,

tools=client.get_code_interpreter_tool(),

)

manager = Agent(

name="Manager",

description="Coordinates the team",

instructions="You coordinate the team to finish complex tasks.",

client=client,

)

workflow = MagenticBuilder(

participants=[researcher, coder],

manager_agent=manager,

max_round_count=10,

max_stall_count=3,

max_reset_count=2,

).build()

task = (

"Compare the training and inference energy use of ResNet-50, BERT-base, "

"and GPT-2, estimate the CO2 for each, and recommend the most efficient "

"model per task type."

)

async for event in workflow.run(task, stream=True):

if event.type == "output" and isinstance(event.data, AgentResponseUpdate):

print(event.data.text)

The manager reads the task, decides the researcher should pull numbers first, hands the coder the math, checks a progress ledger each round, and synthesizes the final answer.

If the team stops making progress, the manager can reset and replan. The max_* values are the guardrails you set. Everything between the goal and the answer is the manager’s call.

More than magentic

Magentic is the sharpest example, but the release is broader. Handoff gives you routed specialist teams. Group chat gives you moderated collaboration. Sequential and concurrent cover pipelines and fan-out/fan-in work.

All of those orchestration patterns now have the same stable footing in Python and .NET. That matters when you are standardizing how agents work across services, teams, or languages.

Because the builders produce workflows, they do not close off the lower-level APIs.

If your team needs a different shape, take the parts that fit and build a custom workflow from the same primitives.

Try magentic on a task you would not trust to a hand-wired pipeline. Try handoff when the routing rules matter. Try sequential or concurrent when the workflow should stay deterministic.

Then tell us where the patterns fit, where they break, and what still feels too hard. Open an issue on GitHub when something is missing or surprising; that feedback shapes what comes next.

Get started with the magentic orchestration docs.

The full samples on GitHub show the other orchestration patterns too.

The post Agent Framework’s Orchestration Patterns Reach 1.0 appeared first on Microsoft Agent Framework.