Microsoft Agent Framework 1.0: Building and Deploying Multi-Agent Workflows in Production

TL;DR: Microsoft shipped Agent Framework 1.0 (MAF) in April 2026 — the production-ready successor to both Semantic Kernel and AutoGen. It unifies AutoGen’s multi-agent patterns with Semantic Kernel’s enterprise features (type safety, middleware, telemetry) and adds graph-based workflows with checkpointing, human-in-the-loop, and MCP/A2A protocol support. Python and .NET SDKs ship as first-class citizens, with connectors for Foundry, OpenAI, Anthropic, Bedrock, Gemini, and Ollama.

---

What Is Microsoft Agent Framework?

Microsoft Agent Framework (MAF) is an open-source, production-grade SDK for building AI agents and multi-agent workflows. Released as v1.0 on April 3, 2026, it consolidates the engineering effort behind two of Microsoft’s most popular AI projects — Semantic Kernel (28K★) and AutoGen (42K★) — into a single, unified codebase [1].

The framework is available for Python (pip install agent-framework) and .NET (dotnet add package Microsoft.Agents.AI), both at 1.0. According to Microsoft’s Shawn Henry, the 1.0 surface carries a commitment to backward compatibility going forward [2].

Why Merge Two SDKs?

Semantic Kernel excelled at enterprise integration — type safety, middleware pipelines, telemetry via OpenTelemetry, and broad model provider support. AutoGen pioneered conversational multi-agent patterns — group chat, handoff, and human-in-the-loop. But maintaining two agent SDKs confused developers and split engineering investment. Agent Framework is the synthesis: AutoGen’s simple agent abstractions running on Semantic Kernel’s runtime infrastructure, with a new graph-based workflow engine on top [3].

Both predecessor projects are either in maintenance mode (AutoGen) or actively migrating users to MAF (Semantic Kernel). Migration guides exist for both codebases [4].

Architecture: Agents vs Workflows

MAF has two primary capability layers.

Layer	Purpose	Key Features
Agents	Individual LLM-powered agents	Providers, middleware, memory (session/key-value/vector), MCP tool integration
Workflows	Multi-step orchestration	Graph-based (Python + .NET), functional (@workflow decorator, Python only), checkpointing, streaming, HITL

When to use an agent vs a workflow: Microsoft’s rule of thumb is simple — use a single agent when the task is open-ended or conversational and a single LLM call (possibly with tools) suffices. Use a workflow when you need explicit control over execution order, multiple agents or functions must coordinate, or you need deterministic, restartable processes [5].

Getting Started: Single Agent in Python

Here’s the minimal agent setup using Azure Foundry deployment:

import asyncio
from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential

agent = Agent(
    client=FoundryChatClient(
        project_endpoint="https://your-foundry-project.services.ai.azure.com",
        model="gpt-5.3",
        credential=AzureCliCredential(),
    ),
    name="HelloAgent",
    instructions="You are a helpful assistant. Keep answers brief.",
)

result = asyncio.run(agent.run("What is the largest city in France?"))
print(f"Agent: {result}")

The equivalent .NET code is ~15 lines using AIProjectClient.AsAIAgent() [1]. The framework supports multiple providers — swap FoundryChatClient for OpenAI, Anthropic Claude, Bedrock, Gemini, or Ollama connectors.

Multi-Agent Patterns: Sequential Workflows

The workflow engine is where MAF differentiates itself. Here’s a sequential writer-reviewer pipeline:

from agent_framework import Agent, Message
from agent_framework.foundry import FoundryChatClient
from agent_framework.orchestrations import SequentialBuilder

client = FoundryChatClient(credential=AzureCliCredential())

writer = Agent(client=client, name="writer",
    instructions="You are a concise copywriter.")
reviewer = Agent(client=client, name="reviewer",
    instructions="You are a thoughtful reviewer.")

workflow = SequentialBuilder(
    participants=[writer, reviewer]
).build()

async for event in workflow.run(
    "Write a tagline for MAF 1.0.", stream=True
):
    if event.type == "output":
        for msg in event.data:
            print(f"[{msg.author_name}]: {msg.text}")

Built-in orchestration patterns include: sequential, concurrent, handoff, group chat, and Magentic-One [2]. All support streaming, checkpointing, and human-in-the-loop pause/resume.

Production Features

1. Middleware Pipeline

Middleware hooks intercept the agent request/response cycle — useful for content safety filtering, compliance logging, metrics collection, and prompt injection detection. The middleware system is modeled on Semantic Kernel’s filters, which have been battle-tested in enterprise deployments since 2023 [3].

2. Checkpointing and Recovery

Workflows support automatic checkpointing at step boundaries. If a long-running workflow crashes mid-execution, it can be hydrated from the last checkpoint and resumed. This is critical for production pipelines that process data overnight or coordinate human approvals [5].

3. Observability via OpenTelemetry

Built-in OpenTelemetry integration emits traces for every agent invocation, tool call, and workflow step. No third-party agent monitoring service required — pipe traces to your existing observability stack (Grafana, Datadog, SigNoz).

4. Declarative Agents (YAML)

Define agents and workflows in YAML for version control and CI/CD integration:

name: support-agent
model: gpt-5.3
instructions: "You are a customer support agent."
tools:
  - name: search_knowledge_base
    type: mcp
    server: "mcp://kb.internal:8000"

Load declarative agents with a single API call — useful for teams that want agent definitions in version control alongside application code [2].

Protocol Support: MCP and A2A

MAF 1.0 ships with MCP (Model Context Protocol) support, letting agents dynamically discover and invoke external tools exposed over MCP-compliant servers. This means your agents can pull data from a knowledge base, file system, or database through a standardized protocol without custom integration code.

A2A (Agent-to-Agent) protocol support is marked as “coming soon” for A2A 1.0, enabling cross-runtime agent collaboration — your MAF agents will coordinate with agents running in other frameworks (e.g., LangGraph, CrewAI, or Google ADK) using structured, protocol-driven messaging [2].

This is part of a broader industry push toward agent interoperability standards in 2026, alongside the Agent Communication Protocol (ACP).

Migration from Semantic Kernel or AutoGen

Microsoft publishes dedicated migration guides [4]:

• From Semantic Kernel: MAF adopts SK’s middleware pattern, OpenTelemetry integration, and provider architecture. Most SK connector code maps directly to MAF’s agent_framework package. The biggest change is replacing Kernel with Agent as the primary abstraction.
• From AutoGen: MAF’s SequentialBuilder, GroupChat, and handoff patterns map almost one-to-one with AutoGen’s AssistantAgent orchestration. The workflow engine replaces AutoGen’s GroupChatManager with explicit graph-based control flow.

Both guides include automated code analysis tools that identify migration patterns in your existing codebase.

When Not to Use MAF

MAF is not the right choice for every scenario. Consider alternatives when:

• You need pure minimalism: Hugging Face’s Smolagents (14.8K★) runs agents in ~1,000 lines of code with no SDK dependencies. If your use case is single-agent research or rapid prototyping, MAF’s abstractions add overhead you don’t need.
• You’re already deep in LangChain ecosystem: LangGraph has a larger community, more tutorials, and deeper LangSmith integration. Migration cost may outweigh MAF’s benefits for established LangGraph deployments.
• You need cloud-only managed agents: Azure Foundry Agent Service provides a managed, no-code approach. MAF is the self-hosted SDK — you manage the runtime.
• You’re on JavaScript/TypeScript: MAF is Python and .NET. For JS-native agents, look at AgentKit, Open Multi-Agent (TypeScript), or Vercel AI SDK.

Bottom Line

Microsoft Agent Framework 1.0 is a credible entry in the production agent SDK space. Its advantage over LangGraph: first-class .NET support, simpler API surface, and Microsoft’s investment in standards (MCP, A2A). Its advantage over Smolagents: enterprise middleware, checkpointing, observability, and multi-language support. Its advantage over AG2: active Microsoft engineering investment and a clear migration path from the older codebases.

For teams building multi-agent systems that need deterministic orchestration, recovery, and enterprise governance, MAF is worth evaluating today.

---

Related Reads

• Smolagents vs Microsoft Agent Framework vs AG2: SDK Comparison — Side-by-side benchmarks and decision guide
• Research Agent with LangGraph and OpenTelemetry Tutorial — Building observable agent systems
• Vendor Agent SDK Comparison: Openai Agents SDK, LangGraph, CrewAI, MAF — Full landscape analysis
• Self-Healing CI/CD Automation Patterns 2026 — Production deployment patterns
• The Agent Service Mesh: Production Patterns for Inter-Agent Communication — Inter-agent communication governance patterns
• Hermes Agent Multi-Agent Setup Guide 2026 — Running specialized AI agents

---

References

[1] Microsoft Agent Framework GitHub — https://github.com/microsoft/agent-framework [2] Microsoft Agent Framework v1.0 Announcement — https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/ [3] Microsoft Agent Framework Overview — https://learn.microsoft.com/en-us/agent-framework/overview/ [4] Migration Guide from Semantic Kernel — https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-semantic-kernel/ [5] Microsoft Agent Framework Workflows — https://learn.microsoft.com/en-us/agent-framework/workflows/ [6] Visual Studio Magazine: “Microsoft Ships Production-Ready Agent Framework 1.0” — https://visualstudiomagazine.com/articles/2026/04/06/microsoft-ships-production-ready-agent-framework-1-0-for-net-and-python.aspx

← Back to all posts