Microsoft Agent Framework
Also known as: Agent Framework, MS Agent Framework, MAF
- Microsoft Agent Framework
- An open-source Microsoft SDK for building agentic and multi-agent applications in .NET and Python. It unifies the earlier AutoGen and Semantic Kernel projects, adds a graph-based workflow engine, and supports the Agent-to-Agent and Model Context Protocol standards natively.
Microsoft Agent Framework is Microsoft’s open-source SDK for building agentic and multi-agent systems in .NET and Python, replacing both AutoGen and Semantic Kernel under a single unified runtime with a graph-based workflow engine.
What It Is
Teams that try to ship multi-agent systems quickly hit the same wall: language models can plan and call tools, but the surrounding code — session state, retries, telemetry, human approvals, safe handoffs between agents — has to be written from scratch every time. Microsoft Agent Framework is the SDK that gives you that surrounding code as a supported product instead of a side project, so engineers can focus on what each agent does instead of how the runtime survives a failure.
The framework is the direct successor to two earlier Microsoft projects. AutoGen, which came out of Microsoft Research, contributed the agent abstractions and orchestration ideas. Semantic Kernel contributed the enterprise plumbing — typed contracts, middleware, telemetry, session-based state. According to Microsoft Foundry Blog, Agent Framework merges both into one product, and both predecessors moved into maintenance mode (bug fixes and security patches only). According to Microsoft Agent Framework v1.0, the framework reached version 1.0 on April 3, 2026, with stable APIs and long-term support commitments.
Architecturally, Agent Framework gives you three layers. At the bottom, agent primitives wrap calls to a model provider — Azure OpenAI, OpenAI, Anthropic Claude, Amazon Bedrock, Google Gemini, or Ollama, according to Microsoft Agent Framework v1.0. In the middle, orchestration patterns combine agents into a system: Sequential, Concurrent, Handoffs, Group Chat, and Magentic-One. On top sits a graph-based workflow engine, where each node can be an agent, a tool call, or a human approval step. Native support for the Agent-to-Agent (A2A) protocol lets agents from different runtimes collaborate, and Model Context Protocol (MCP) integration lets agents discover external tools dynamically rather than having every tool hard-coded into the application.
How It’s Used in Practice
Most teams meet Agent Framework when they need to ship a coordinated set of agents inside an enterprise stack — typically a .NET application on Azure, or a Python service that has to integrate with existing identity, logging, and approval systems. A customer support workflow is a common starting point: a triage agent reads incoming tickets, hands urgent ones to a specialist agent, and routes refund decisions to a human approver before the action is committed. The framework handles session state, typed handoff contracts, retries, and the audit trail.
The other mainstream entry point is migrating an existing AutoGen prototype or Semantic Kernel pilot. According to Migration Guide, Microsoft publishes step-by-step paths from both predecessors, so the typical move is preserving the agent design and swapping the underlying runtime.
Pro Tip: Start with the Sequential or Handoffs pattern before reaching for Group Chat or Magentic-One. Multi-agent systems fail far more often from unclear handoff contracts than from a lack of fancy orchestration. Get one clean handoff working end to end, with telemetry and a human-in-the-loop checkpoint, before you let agents talk to each other freely.
When to Use / When Not
| Scenario | Use | Avoid |
|---|---|---|
| Enterprise app on .NET or Azure needing supported multi-agent runtime | ✅ | |
| Single-agent chatbot with no tool calls or coordination | ❌ | |
| Migrating an AutoGen or Semantic Kernel project to a supported path | ✅ | |
| Quick research prototype where you want minimal abstractions | ❌ | |
| System that must coordinate agents across different runtimes via A2A | ✅ | |
| Team with no SDLC, no logging, and no approval process for agent actions | ❌ |
Common Misconception
Myth: “Agent Framework reaching 1.0 means I have to rewrite my AutoGen or Semantic Kernel project right now or it will stop working.” Reality: Both predecessors are in maintenance mode, not end-of-life — they continue to receive security and bug fixes. According to Migration Guide, Microsoft publishes a structured migration path so teams can move on their own schedule. New work should target Agent Framework, but existing systems keep running.
One Sentence to Remember
Microsoft Agent Framework is the runtime layer for multi-agent systems in the Microsoft stack — pick it when you need a supported .NET-and-Python SDK with handoffs, telemetry, and human-in-the-loop already wired in, and skip it when a single agent with a few tools would do.
FAQ
Q: Is Microsoft Agent Framework the same as AutoGen? A: No. Agent Framework is the successor that absorbed AutoGen’s orchestration ideas and Semantic Kernel’s enterprise plumbing. AutoGen itself is now in maintenance mode, and the community fork that continues active development is called AG2.
Q: Does Agent Framework only work with Azure OpenAI? A: No. According to Microsoft Agent Framework v1.0, it ships with first-class support for Azure OpenAI, OpenAI, Anthropic Claude, Amazon Bedrock, Google Gemini, and Ollama, so teams can pick a provider without changing the surrounding agent code.
Q: Is Microsoft Agent Framework production-ready? A: Yes. According to Microsoft Agent Framework v1.0, the framework reached version 1.0 on April 3, 2026 with stable APIs, long-term support commitments, and enterprise features such as session state, checkpointing, telemetry, and human-in-the-loop already built in.
Sources
- Microsoft Agent Framework v1.0: Microsoft Agent Framework Version 1.0 - Official GA announcement covering scope, providers, and orchestration patterns.
- Microsoft Foundry Blog: Introducing Microsoft Agent Framework - Background on the unification of AutoGen and Semantic Kernel.
Expert Takes
A framework like this does not make agents smarter. It makes coordination cheaper. The hard problem in multi-agent systems is not deciding what each agent does — it is tracking shared state, handling failures, and stopping infinite handoff loops. Microsoft Agent Framework standardises the plumbing around those problems. The cognitive limits of the underlying language model still apply. The framework cannot create reasoning that the model itself does not produce.
Specifications matter more than orchestration patterns. Agent Framework gives you sequential, concurrent, and handoff orchestrators out of the box, but pick the wrong one and your agents fight over shared context. Write a clear specification first: what each agent owns, what it returns, and where its responsibility ends. Then choose the pattern that matches the contract. The framework is good infrastructure, but infrastructure cannot rescue an unclear handoff design.
Microsoft just consolidated two separate communities — AutoGen researchers and Semantic Kernel enterprise developers — under one runtime. That is a strategic move. Enterprise buyers wanted Microsoft to pick a lane and back it for the long haul. They got it. Teams shipping multi-agent systems on Azure now have an officially supported path with first-class .NET. The competitive pressure shifts to LangGraph and CrewAI to match the enterprise plumbing story. The window for vendor neutrality is closing.
Who is responsible when an autonomous agent built on this framework takes a costly action no human approved? The framework supports human-in-the-loop, but it does not require it. Defaults shape behaviour. If teams ship configurations that hand control to agents because that path is easier, the same questions about audit trails and accountability that haunt other agentic systems will follow this one. The framework is neutral. The deployments are not.