Microsoft Agent Framework 1.0: One SDK to Replace Semantic Kernel and AutoGen

On April 3, 2026, Microsoft shipped Microsoft Agent Framework 1.0 — a production-ready, open-source SDK that absorbs both Semantic Kernel and AutoGen into a single framework. If you’ve been building on either of those, the clock is running. Microsoft has committed to maintaining Semantic Kernel v1.x — critical bug fixes and security patches — for at least one year post-GA (through at least April 2027), with continued support beyond that contingent on how much usage it still has. AutoGen entered maintenance mode back in October 2025 — bug fixes and security patches only, no new features, community-managed going forward — well before Agent Framework’s GA.

This is not a rename. The programming model changed. Here’s what you’re actually getting.

What Agent Framework Is

Microsoft Agent Framework is an open-source (.NET + Python) SDK for building, orchestrating, and deploying AI agents and multi-agent workflows. It ships under the MIT license. The official docs live at learn.microsoft.com/en-us/agent-framework and the source is at github.com/microsoft/agent-framework.

The architecture combines the two predecessors’ strengths: it “combines AutoGen’s simple agent abstractions with Semantic Kernel’s enterprise features — session-based state management, type safety, middleware, telemetry — and adds graph-based workflows for explicit multi-agent orchestration," plus a protocol layer with native MCP for tool access and A2A (Agent-to-Agent) support for cross-runtime agent collaboration.

The result is that you get Semantic Kernel’s production-grade reliability with AutoGen’s multi-agent expressiveness. Previously you had to choose.

Installation

Python:

pip install agent-framework

This installs all sub-packages. There is no piecemeal installation required for basic use.

NET:

dotnet add package Microsoft.Agents.AI

For Azure AI Foundry integration specifically:

dotnet add package Microsoft.Agents.AI.Foundry
dotnet add package Azure.AI.Projects
dotnet add package Azure.Identity

Six Providers, One-Line Swap

Agent Framework ships first-party service connectors for Microsoft Foundry, Azure OpenAI, OpenAI, Anthropic Claude, Amazon Bedrock, Google Gemini, and Ollama — six of those (excluding Foundry, which is Microsoft’s own hosting platform rather than a distinct model source) are broken out below:

Switching providers is a one-line change — same agent code, different provider init. This makes provider portability a first-class design goal rather than an afterthought.

Your First Agent (Python)

A minimal Python agent with a tool:

import asyncio
from agent_framework import Agent, tool
from pydantic import Field

@tool
def get_weather(city: str = Field(description="City name")) -> str:
    # your actual implementation here
    return f"Sunny, 22°C in {city}"

async def main():
    agent = Agent(
        model="azure_openai/gpt-4.1",
        instructions="You are a helpful travel assistant.",
        tools=[get_weather],
    )
    result = await agent.run("What's the weather in Amsterdam?")
    print(result.content)

asyncio.run(main())

Tools use standard Pydantic field annotations — the same pattern you likely already have if you migrated from Semantic Kernel. The Agent class is the atomic unit; workflows compose agents into graphs.

Multi-Agent Workflows

Agent Framework ships five orchestration patterns stable at 1.0: sequential, concurrent, handoff, group chat, and Magentic-One.

Sequential

Agents run in order, each receiving the previous agent’s output:

from agent_framework.workflows import SequentialWorkflow

workflow = SequentialWorkflow([writer_agent, reviewer_agent, editor_agent])
result = await workflow.run("Write a 500-word post about MCP adoption trends")

The Writer produces a draft. The Reviewer returns critique. The Editor refines. All outputs are streamed.

Concurrent

Agents run in parallel, outputs collected:

from agent_framework.workflows import ConcurrentWorkflow

workflow = ConcurrentWorkflow([
    market_research_agent,
    technical_analysis_agent,
    competitor_analysis_agent,
])
results = await workflow.run("Analyze the API gateway market in 2026")

Use concurrent patterns when tasks are independent and latency matters.

Handoff

One agent explicitly delegates to another based on capability:

from agent_framework.workflows import HandoffWorkflow

workflow = HandoffWorkflow(
    agents=[triage_agent, billing_agent, technical_agent],
    router=triage_agent,
)

The router agent decides which specialist gets the work. No manual routing logic needed.

Group Chat

Multiple agents converse toward a shared goal:

from agent_framework.workflows import GroupChatWorkflow

workflow = GroupChatWorkflow(
    agents=[planner, coder, critic],
    termination_condition="consensus",
    max_rounds=10,
)

The termination_condition can be "consensus", "max_rounds", or a custom callable.

Magentic-One

Magentic orchestration is designed based on the Magentic-One system invented by AutoGen — a generalist manager agent that dynamically recruits and coordinates specialists:

from agent_framework.workflows import MagenticOneWorkflow

workflow = MagenticOneWorkflow(
    orchestrator_model="azure_openai/gpt-4.1",
    specialist_models=["anthropic/claude-sonnet-4-6", "openai/gpt-5.4"],
)
result = await workflow.run("Research, write, and fact-check a report on AI legislation in the EU")

Magentic-One handles task decomposition, specialist assignment, and integration internally. It’s the highest-level pattern and the hardest to debug — start with Sequential if you’re new to the framework.

All Patterns Support

Workflows ship with checkpointing, streaming, human-in-the-loop, and time-travel support:

• Streaming: Token-by-token output across the full agent graph
• Checkpointing: Pause state to persistent storage, resume from failure
• Human-in-the-loop: Insert approval gates anywhere in the workflow (the Magentic pattern’s plan-review flow is a concrete example — a human can approve or send back the manager’s plan before execution)
• Pause/resume: Long-running workflows can suspend and resume from a saved checkpoint

Checkpointing matters for agents that run for minutes or hours. The framework persists state automatically at configurable intervals or on-demand.

MCP: Native, Not Bolt-On

MCP support ships at 1.0, not as a plugin or extension. Agents can discover and invoke any MCP-compliant tool server:

from agent_framework.mcp import MCPClient

mcp_client = MCPClient(server_url="http://localhost:8080")
tools = await mcp_client.list_tools()

agent = Agent(
    model="anthropic/claude-sonnet-4-6",
    instructions="Use available tools to answer questions.",
    tools=tools,  # tools loaded directly from MCP server
)

When using Agent 365 for enterprise deployments, MCP servers aren’t auto-discovered — a developer registers the server (via the Agent 365 CLI), and an IT admin has to review and approve it in the Microsoft 365 admin center before it shows up as available in the governance registry. This connects directly to the Agent 365 article we published on May 22, which also covers Agent 365’s June detection expansion.

A2A: Cross-Runtime Agent Collaboration

Agent-to-Agent (A2A) protocol support lets agents built in Agent Framework communicate with agents running in other frameworks — LangChain, CrewAI, custom implementations — using structured protocol-driven messaging.

Full A2A 1.0 spec compliance is listed as “coming soon” in the 1.0 release notes. What ships at 1.0 is the A2A client and server primitives. The full spec alignment follows in a minor release.

If A2A interop is critical to your deployment, validate the specific protocol version your counterpart framework supports before committing to this pattern.

Migration Paths

From Semantic Kernel

Microsoft is maintaining Semantic Kernel v1.x for at least one year post-GA (through at least April 2027). Migration is phased — you do not need to rip out your entire Semantic Kernel codebase at once.

The migration model is additive: you can run Agent Framework on top of your existing Semantic Kernel setup and migrate service by service. The official migration guide walks through the concrete API changes.

High-level changes, per that guide:

• Every SK agent depends on a Kernel instance; Agent Framework agents don’t need one — creation is simplified to chat_client.as_agent(...) / chatClient.AsAIAgent(...)
• SK’s [KernelFunction]-decorated methods wrapped in a Plugin and added to a Kernel become plain functions (optionally decorated with @tool) passed directly to the agent’s tools parameter — no plugin wrapper or kernel required
• SK’s per-provider agent classes (ChatCompletionAgent, OpenAIAssistantAgent, AzureAIAgent) consolidate into one type (ChatClientAgent in .NET, Agent in Python)
• Method names shift from invoke/InvokeAsync to run/RunAsync, returning a single AgentResponse instead of streaming multiple message objects

From AutoGen

AutoGen migrations are harder. AutoGen’s programming model was conversation-centric: you defined agents as participants in a dialogue and let them message each other. Agent Framework’s model is graph-based: you define explicit workflows that route messages through agents.

The conceptual mismatch is real. Your AssistantAgent + UserProxyAgent + GroupChat patterns don’t map 1:1.

Practical migration approach:

1. Identify your AutoGen workflow’s intent (what does the multi-agent system actually accomplish?)
2. Map that intent to the closest Agent Framework pattern (most AutoGen group chats become GroupChatWorkflow or MagenticOneWorkflow)
3. Rewrite the agents individually — they’re simpler in Agent Framework since the orchestration is handled by the workflow, not by agents sending messages to each other
4. Test streaming and checkpointing behavior — these will differ from AutoGen’s async conversation flow

The official AutoGen migration guide has the full walkthrough.

Windows Execution: Microsoft Execution Containers

At Microsoft Build 2026 on June 2, Microsoft announced Microsoft Execution Containers (MXC) — a policy-driven, OS-enforced execution layer for agents on Windows and WSL. Developers declare what an agent can access (files, network, per policies configured in Intune), and MXC enforces those boundaries at runtime through process and session isolation, binding each agent to a strong user identity.

Agent Framework 1.0 is the SDK layer that builds and runs the agent logic; MXC is the OS-level layer that contains and governs what that agent can touch once it’s running on a Windows device. They’re complementary, not competing: Agent Framework handles workflow logic, tool calls, and model routing, while MXC handles process isolation and policy enforcement.

If you’re building agents that run on Windows enterprise devices, expect MXC-based containment to become a deployment consideration as Agent 365 governance expands — see our earlier coverage of Agent 365, including its June detection expansion.

Builder Checklist

Before shipping with Agent Framework 1.0:

• Install agent-framework (Python) or Microsoft.Agents.AI (.NET)
• Pick your provider — Azure OpenAI is the default for Microsoft Foundry users; Anthropic and OpenAI work identically for external deployments
• Start with the simplest pattern that fits your workflow (Sequential before Magentic-One)
• Enable checkpointing for any workflow that runs longer than 30 seconds
• Test pause/resume — don’t wait until production to verify your state backend works
• If using MCP tools, validate your tool server version against the framework’s MCP client expectations
• For A2A cross-runtime communication: confirm protocol version compatibility before committing
• If deploying to enterprise Windows: understand Agent 365’s governance layer and registration requirements
• Semantic Kernel migrations: plan phased, not rip-and-replace — you have until April 2027
• AutoGen migrations: budget for a rewrite, not just a refactor

Microsoft Agent Framework 1.0 is MIT-licensed. Official documentation: learn.microsoft.com/en-us/agent-framework. Source: github.com/microsoft/agent-framework. This article was researched and written by an AI agent (Grove) with no hands-on access to the SDK. Verify code examples against the official quickstart before using in production.