Microsoft Agent Framework Explained: AutoGen’s Successor
What Microsoft Agent Framework is, how its agents and workflows work, how it maps onto AutoGen, and a runnable example that needs no API key
Microsoft Agent Framework (MAF) is Microsoft’s SDK for building AI agents and multi-agent workflows in Python and .NET. It exists because AutoGen is archived: AutoGen’s README tells new users to start here, and Microsoft’s migration guide describes MAF as developed by the core AutoGen and Semantic Kernel teams. This guide covers what it is, how its pieces fit together, and how AutoGen concepts map across. Checked against agent-framework 1.26.0 (Python 3.11 or later) on 14 November 2026. See the resource page for the project link.
Where it stands
The repository was created in April 2025, the first stable 1.0.0 reached PyPI on 2 April 2026, and releases have been frequent since: 1.26.0 on 12 November 2026. It is MIT licensed and has Python and .NET implementations with consistent APIs, plus a separate Go SDK. That is a fast cadence for a project that is a few months past 1.0, so pin a version and read the release notes before upgrading.
Installing it
pip install agent-framework is a meta-package for agent-framework-core[all], and in 1.26.0 it pulls in about thirty packages: OpenAI, Foundry, Anthropic, Ollama, Gemini, Mistral and Bedrock clients, the orchestration builders, DevUI, memory and hosting integrations. The core package alone is small, but it does not include a model client or the orchestration builders: importing agent_framework.openai or agent_framework.orchestrations from agent-framework-core alone raises a ModuleNotFoundError that names the missing package. For a lean install, add only what you use:
pip install agent-framework-core agent-framework-openai agent-framework-orchestrationsAgents
An agent wraps a model client, instructions and optional tools. The client is where the provider lives: OpenAIChatClient (the Responses API), OpenAIChatCompletionClient, FoundryChatClient, AnthropicClient and OllamaChatClient all import cleanly in 1.26.0. Tools are plain Python functions marked with @tool; the schema comes from the signature and docstring. This example needs an API key, so it is shown rather than run:
import asyncio
from agent_framework import Agent, tool
from agent_framework.openai import OpenAIChatClient
@tool
def get_weather(city: str) -> str:
"""Look up the weather for a city."""
return f"Sunny in {city}"
async def main():
agent = Agent(
client=OpenAIChatClient(model="<a current model ID>"), # reads OPENAI_API_KEY
name="WeatherAgent",
instructions="Answer briefly, using the tool when needed.",
tools=[get_weather],
)
print(await agent.run("What's the weather in Paris?"))
asyncio.run(main())Per Microsoft’s migration guide, an Agent is multi-turn by default and keeps calling tools until it can return a final answer, whereas AutoGen’s AssistantAgent stopped after one tool round unless you raised max_tool_iterations.
Workflows and orchestration patterns
Multi-agent coordination is where MAF differs most from AutoGen. Instead of a team of agents chatting, you build a typed Workflow, a graph where executors (agents or plain functions) are connected by edges and run when their inputs are ready. The agent_framework.orchestrations module ships ready-made builders for the common shapes: SequentialBuilder, ConcurrentBuilder, GroupChatBuilder, HandoffBuilder and MagenticBuilder. The framework also supports checkpointing, streaming and human-in-the-loop requests on those workflows.
You can try the builders without an API key by giving the agents a stand-in client. This runs on agent-framework-core and agent-framework-orchestrations only:
import asyncio
from agent_framework import Agent, BaseChatClient, ChatResponse, Message
from agent_framework.orchestrations import ConcurrentBuilder, SequentialBuilder
class CannedClient(BaseChatClient):
"""Stands in for a real model so the example runs offline."""
def __init__(self, reply: str):
super().__init__()
self.reply = reply
async def _inner_get_response(self, *, messages, stream, options, **kwargs):
return ChatResponse(messages=[Message("assistant", [self.reply])])
def agent(name: str, reply: str) -> Agent:
return Agent(client=CannedClient(reply), name=name, instructions=f"You are {name}.")
async def main():
writer = agent("writer", "draft")
reviewer = agent("reviewer", "approved")
sequential = SequentialBuilder(participants=[writer, reviewer]).build()
result = await sequential.run("Write a note about uv")
print([output.text for output in result.get_outputs()]) # ['approved']
concurrent = ConcurrentBuilder(participants=[writer, reviewer]).build()
result = await concurrent.run("Review this")
print([output.text for output in result.get_outputs()]) # ['draftapproved']
asyncio.run(main())With a real model the sequential workflow passes the conversation from writer to reviewer, and here the final output is the reviewer’s reply. The concurrent workflow runs both at once and returns their combined output. The output type changed in places across versions (Microsoft’s migration guide shows a list of messages, while 1.26.0 returned an AgentResponse here), so check what your version returns.
Mapping from AutoGen
Microsoft’s own migration guide, last updated 23 October 2026, gives these equivalents:
| AutoGen | Microsoft Agent Framework |
|---|---|
AssistantAgent(name, model_client, tools) |
Agent(name=..., client=..., tools=[...]) |
await agent.run(task="...") |
await agent.run("...") |
FunctionTool wrapper |
@tool decorator, schema inferred |
RoundRobinGroupChat |
SequentialBuilder (Microsoft’s suggested match) |
MagenticOneGroupChat |
MagenticBuilder |
GraphFlow |
Workflow |
Event-driven runtime, Team |
Typed graph-based Workflow |
Single turn unless max_tool_iterations > 1 |
Multi-turn by default |
The guide’s own summary is that single-agent migration is straightforward, while multi-agent code needs rethinking from event-driven to data-flow. It also notes that MAF focuses on single-process composition today, with distributed execution planned. That page lists Anthropic and Ollama clients as “planned”, yet agent-framework-anthropic and agent-framework-ollama are in the 1.26.0 install and import, so the documentation lags the code in places.
How it compares
- Against AutoGen: maintained, with a graph-based model instead of free conversation. Group chat and handoff patterns survive as workflow builders.
- Against LangGraph: both use explicit graphs. MAF is first-party for Azure and Foundry and has a .NET implementation; LangGraph has the longer track record in Python and the larger ecosystem around LangChain.
- Against CrewAI: CrewAI is more opinionated and role-based, and faster to start with. MAF gives more control and a typed workflow layer, at the cost of more concepts. See CrewAI vs AutoGen and Python AI agent frameworks compared.
What this guide did not test
The offline example above was run on agent-framework-core 1.26.0 and agent-framework-orchestrations 1.4.2 (the sub-packages are versioned separately from the agent-framework meta-package). The OpenAI agent example, Foundry quickstart and the group chat, handoff and Magentic builders were not run against a live model, so treat those as the documented pattern rather than a tested result.
Frequently Asked Questions
What is Microsoft Agent Framework?
An open-source (MIT) SDK from Microsoft for building AI agents and multi-agent workflows in Python and .NET. It was built by the teams behind AutoGen and Semantic Kernel, and Microsoft names it as the successor to AutoGen, which is now archived.
Is Microsoft Agent Framework the same as AutoGen?
No. It keeps AutoGen’s ideas (agents with a model client, instructions and tools, plus multi-agent patterns such as group chat and Magentic) but replaces the event-driven team model with typed, graph-based workflows. It is a new package, agent-framework, with a different API, and Microsoft publishes a migration guide.
How do you install it?
pip install agent-framework installs the standard set, which in version 1.26.0 is about thirty packages (OpenAI, Foundry, Anthropic, Ollama and orchestration support among them). For a smaller install, use agent-framework-core plus only what you need, such as agent-framework-openai and agent-framework-orchestrations. It requires Python 3.11 or later.
Is it production ready?
Microsoft describes it as production-ready, and version 1.0.0 was released on PyPI on 2 April 2026, with frequent releases since (1.26.0 on 12 November 2026). It is much newer than LangGraph or CrewAI in practice, so expect the API to keep moving between minor versions.