Microsoft Agent Framework

Microsoft Agent Framework (MAF) is Microsoft's open-source SDK for agents and multi-agent workflows in Python and .NET. It unifies its two earlier projects: the simple agent abstractions and multi-agent patterns of AutoGen and the enterprise features of Semantic Kernel (sessions, middleware, telemetry, connectors), adding graph-based workflows with checkpointing. Announced in October 2025, it is Microsoft's recommended path for new projects; AutoGen and Semantic Kernel code is migrated to it.

Agents

An agent wraps a chat client (OpenAI, Azure OpenAI, Foundry, Anthropic, Bedrock, Gemini, Ollama and others ship as connector packages) with instructions, tools, middleware and context providers:

from agent_framework import Agent, Message, tool
from agent_framework.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient("gpt-5-mini")                 # or base_url=... for any compatible server
tools = [tool(fn, approval_mode="always_require" if fn.__name__ == "refund_item" else "never_require")
         for fn in shop_functions]
agent = Agent(client, POLICY, name="shop_support", tools=tools)

session = agent.create_session()                                   # conversation state across runs
response = await agent.run(request, session=session)
while response.user_input_requests:                                # paused before a refund
    answers = [r.to_function_approval_response(True) for r in response.user_input_requests]
    response = await agent.run(Message("user", answers), session=session)
print(response.text)

• Tools: plain functions (schema from type hints), @tool with approval_mode and max_invocations, hosted tools of the provider, and MCP (MCPStdioTool, MCPStreamableHTTPTool).
• Middleware intercepts agent runs, chat calls and function calls - for logging, policy checks, or rewriting arguments and results.
• Context providers inject memory or retrieved context before each run (Mem0, Redis and Azure AI Search integrations exist).
• Telemetry follows the OpenTelemetry GenAI conventions.

Workflows

Workflows are typed graphs of executors (functions, classes or agents) connected by edges. Messages flow along edges; an executor sends messages onward or yields workflow outputs.

from typing_extensions import Never
from agent_framework import Case, Default, WorkflowBuilder, WorkflowContext, executor

@executor(id="assess")
async def assess(amount: float, ctx: WorkflowContext[float]) -> None:
    await ctx.send_message(amount)

@executor(id="auto_approve")
async def auto_approve(amount: float, ctx: WorkflowContext[Never, str]) -> None:
    await ctx.yield_output(f"auto-approved {amount}")

@executor(id="needs_review")
async def needs_review(amount: float, ctx: WorkflowContext[Never, str]) -> None:
    await ctx.yield_output(f"sent {amount} to a reviewer")

workflow = (WorkflowBuilder(start_executor=assess)
            .add_switch_case_edge_group(assess, [Case(condition=lambda a: a > 100, target=needs_review),
                                                 Default(target=auto_approve)])
            .build())
print((await workflow.run(120.0)).get_outputs())     # ['sent 120.0 to a reviewer']  (verified, MAF 1.19)

flowchart LR
    S["▶️ assess"] -->|"amount > 100"| R["👩‍⚖️ needs_review"]
    S -->|"default"| A["✅ auto_approve"]
    R --> O["📤 outputs"]
    A --> O

    style S fill:#d8dfe8,stroke:#b0bac8
    style R fill:#e8e0d4,stroke:#c8b89a
    style A fill:#dde4dc,stroke:#b0c4b0

The builder has chains, fan-out and fan-in edges, switch-case and multi-selection edge groups. Execution proceeds in supersteps; with a checkpoint_storage (in-memory or file, among others) state is saved at superstep boundaries so a workflow can pause - for example on ctx.request_info(...), which asks a human or external system for input - and resume later, even in another process. Workflows can also be declared in YAML (agent-framework-declarative) and wrapped as an agent.

Multi-Agent Orchestrations

Pre-built patterns in agent_framework.orchestrations, all built on workflows:

Builder	Pattern
SequentialBuilder	Agents in a pipeline, each seeing the conversation so far
ConcurrentBuilder	Agents in parallel on the same input, results aggregated
HandoffBuilder	Agents transfer control to each other (triage to specialists)
GroupChatBuilder	A manager selects the next speaker in a shared conversation
MagenticBuilder	A Magentic-One style orchestrator with a task ledger and progress ledger, re-planning when stuck; optional plan review by a human

These map directly onto the topologies in Multi-Agent Architectures; the evidence there on when multiple agents help applies unchanged.

From AutoGen and Semantic Kernel

Earlier	In MAF
AutoGen AssistantAgent	Agent
AutoGen team patterns (RoundRobin, Selector, Swarm, Magentic-One)	Orchestration builders
Semantic Kernel plugins and functions	Tools (functions, @tool) and MCP
Semantic Kernel filters	Middleware
Semantic Kernel process framework	Workflows

Deployment targets include Azure Functions (durable agents), Foundry Agent Service, and any container; agent-framework-devui gives a local UI for runs and traces, and AG-UI and A2A adapters expose agents to front ends and other agents.

Check Yourself

Exercises

Study Notes

• MAF = AutoGen's agents and orchestration patterns + Semantic Kernel's enterprise features + graph workflows; Python and .NET
• Agent(client, instructions, tools=...), sessions, middleware, context providers, OpenTelemetry
• Tool approval: approval_mode="always_require" -> user_input_requests -> to_function_approval_response
• Workflows: executors + edges (switch-case, fan-out/in), supersteps, checkpoints, request_info for human input
• Orchestrations: sequential, concurrent, handoff, group chat, Magentic

References

• Microsoft, Introducing Microsoft Agent Framework (Oct 2025)
• Microsoft Agent Framework documentation - agents, tools, workflows, orchestrations, migration guides (2026)
• Fourney et al., Magentic-One: A Generalist Multi-Agent System (2024)

Last reviewed: 2026-09