What Is the Microsoft Agent Framework? The AutoGen Successor, Explained
Microsoft Agent Framework is the open-source successor to AutoGen and Semantic Kernel: one SDK for building AI agents and multi-agent workflows in Python and .NET, free under the MIT licence, with...

The Short Answer: One Framework Now Carries Both Jobs
Microsoft Agent Framework is Microsoft's open-source SDK for building AI agents and multi-agent workflows. It is the direct successor to AutoGen and Semantic Kernel, built by the same teams that built both.
Table Of Content
- The Short Answer: One Framework Now Carries Both Jobs
- What the Microsoft Agent Framework Is
- Where It Came From: AutoGen and Semantic Kernel in One Place
- AutoGen Is Archived. What That Means If You Already Use It
- Semantic Kernel Users: What Changes and What Does Not
- The Four Parts of the Framework
- Your First Agent in Brief
- Who Should Use It, and Who Should Not
- Microsoft Agent Framework vs LangGraph vs CrewAI
- Moving From AutoGen or Semantic Kernel
- Frequently Asked Questions
- The Decision in Brief
Version 1.0 shipped on 3 April 2026 with stable APIs and a long-term support commitment. It works in Python and .NET, it costs nothing to use, and you pay only your model provider for the tokens your agents consume. If you are starting a new agent project on the Microsoft stack, this is the framework Microsoft wants you to use.
What the Microsoft Agent Framework Is
An AI agent is software that takes a goal, works out the steps, calls tools, reads the results, and acts on them without someone writing every step in advance. A chatbot answers a question and stops. An agent keeps going until the job is done, or until it needs a person to decide something.
The framework gives you the parts such an agent needs, already built and already connected. A chat client talks to the model. Instructions tell the agent what it is and what it may do. Tools let it read files, call APIs, and query databases. Sessions keep memory across turns. Middleware watches every step, and telemetry records what happened so you can trace a bad answer back to its cause.
It is open source under the MIT licence, and the code lives on GitHub. That matters for two reasons. First, you can read exactly what it does instead of trusting a sales page. Second, you are not locked to one model provider.
The same agent can run on Azure OpenAI, OpenAI, Anthropic, Microsoft Foundry, or a local model through Ollama, because the framework talks to all of them through one common chat-client shape.
There is no licence price and no per-seat fee. The only bill is the one your model provider sends for tokens. That is the whole pricing story, and it is worth stating plainly, because several agent tools in this space charge by the seat or by the run.
Where It Came From: AutoGen and Semantic Kernel in One Place

Microsoft did not build this framework from nothing. It took two of its own projects and joined them.
AutoGen came out of Microsoft Research. It was built for multi-agent collaboration, and it gave developers simple ways to describe agents that talk to each other, hand work back and forth, and solve a problem together.
Our guide to AutoGen covers its history in full, and our multi-agent AI frameworks guide puts it beside the other leading options. Its ideas were strong, and researchers liked it. It was never quite built for production use, though, and that gap showed as soon as teams tried to run it in real systems.
Semantic Kernel came from the other direction. It was built for enterprise use, with orchestration, plugins, planners, and the kind of safety rails a company needs before it lets software act on its behalf. It was steady and well supported, but it was also showing its age as agent patterns moved faster than its design.
The new framework takes the simple agent abstractions from AutoGen and the enterprise features from Semantic Kernel: session-based state, type safety, middleware and filters, and telemetry. Then it adds something neither of them had in this form, graph-based workflows that let you draw the exact path several agents follow, with checkpointing, streaming, and a person in the loop where a decision matters.
Microsoft Learn calls it the direct successor to both, and the next generation of both. That is not marketing gloss. The same engineering teams built it.
AutoGen Is Archived. What That Means If You Already Use It
This is the part that trips people up, because Microsoft's own pages still disagree with each other.
The AutoGen repository on GitHub carries a banner that says the project is archived and no longer maintained, and the wording is plain: Microsoft provides no bug fixes, no security fixes, no new features, and no support for the project. The repository stays online for reference, and new users are sent to the Agent Framework. Existing users are sent to Microsoft's migration guide.
One Microsoft Learn training page still says AutoGen is in maintenance mode and receives only bug fixes and security updates. That wording is older, and it conflicts with the banner on the repository itself. The repository is the project's own notice, so it is the one to trust. If you read both pages and they seem to disagree, that is why. They do.
Archived does not mean your running AutoGen code stops working tomorrow. The code you already have keeps running. What changes is the risk.
A security flaw found next month will not be fixed. If a model provider changes its API, no patch will follow. If a new Python version breaks an old dependency, no release will fix it. For a weekend experiment, that risk is small. A system that touches customer data or money is a different story, and it is not a risk worth carrying for long.
The sensible move is to stop starting new work on AutoGen and to plan the move. Microsoft's migration guide on Learn walks through the mapping from AutoGen agents to Agent Framework agents, and it is the best place to start that plan. Our own guide to the best tools for building AI agents already states the archived position correctly, and it needs no correction on this point.
Semantic Kernel Users: What Changes and What Does Not
Semantic Kernel is in a different position, and it is easy to get this wrong. It is not archived, and it is not dead. Releases still ship, and its .NET package reached 1.81.0 on 6 October 2026. Code you have written on it keeps running, and Microsoft has not announced an end date for it.
What has changed is the direction of travel. Microsoft positions the Agent Framework as the successor to Semantic Kernel as well, and it publishes a migration guide for Semantic Kernel users too. New work should start on the Agent Framework. Existing Semantic Kernel systems do not need a rushed rewrite, but a team planning its next agent project should not start it on the older framework.
The practical difference is where the new features land. The Agent Framework gets the new workflow engine, the harness agent, and the Foundry hosted-agent support. Semantic Kernel gets maintenance releases. Over a year or two, that gap will grow. Starting new work on the older tool means rebuilding sooner than you need to.
The Four Parts of the Framework

Microsoft Learn describes four areas, and each one solves a different problem. The table below gives the short version, and the paragraphs after it give one practical use for each.
| Part | What it does | One practical use |
|---|---|---|
| Agents | Single agents that reason, call tools and MCP servers, and keep state across turns | A support agent that reads a ticket, checks the order system, and drafts a reply |
| Harness Agent | An opinionated agent for long multi-step tasks, with planning, todo tracking, context compaction, file access, memory, and tool approval | A research task that runs for an hour, reads twenty sources, and files a report |
| Workflows | Functional and graph-based workflows that connect agents and functions through explicit paths, with checkpointing, streaming, and human approval | A review chain where one agent drafts, a second checks the facts, and a person approves before anything is sent |
| Integrations | Connections to model providers, agent services, tools, context providers, middleware, evaluation, and user interfaces | Swapping Azure OpenAI for a local model without rewriting the agent logic |
Agents are the base unit. You give one a name, an instruction, and a chat client, and it can answer, act, and remember within a session. Most small projects need nothing more than this.
The harness agent is for work that takes a while. A plain agent can lose track of a long task, repeat itself, or forget an early instruction halfway through.
The harness keeps a plan and a todo list, compacts context when the conversation grows long, and asks for approval before a tool call that matters. Think of it as the difference between a colleague who answers one question and a colleague who runs a whole project.
Workflows are for teams of agents. Instead of letting agents chat freely and hoping they reach a good answer, you draw the path: first this agent, then that one, then a check, then a person. The graph shapes are sequential, concurrent, handoff, and group collaboration. Checkpointing means a workflow can pause and resume, and time travel means you can replay a run to find where it went wrong.
Integrations are the quiet part that saves the most time later. Model providers, tools, memory, middleware, and evaluation all plug in through the same shapes. When a provider changes its prices or a team wants a local model for sensitive data, the agent code stays the same and only the provider changes.
Your First Agent in Brief

This is not a tutorial, and it is not trying to be one. It is the shortest honest picture of what starting looks like, so you can judge the size of the step.
On Python, the install is one command:
pip install agent-frameworkOn .NET, it is one package:
dotnet add package Microsoft.Agents.AIA first agent needs three things: a chat client bound to a model, a name, and a short instruction that says what the agent is and what it may do. You call its run method with a prompt, and it returns an answer.
The official quickstart builds an agent that writes a haiku, which sounds trivial, and it is. The point of the example is the shape, not the poem. That same shape scales to an agent with tools, memory, and a workflow behind it.
You also need a model provider and a key, and you set that up before the code runs. The framework does not load .env files for you, so either call load_dotenv() at the start of your program or set the variables in your shell. That is a small detail, and it is the one that catches the most beginners.
Who Should Use It, and Who Should Not
New production work with more than one agent should start here, especially on the Microsoft stack. If your team already uses .NET and Microsoft.Extensions.AI, the fit is natural, because the framework builds directly on those same pieces. If you need durability, observability, and a person in the loop for decisions that matter, those features are built in rather than bolted on.
A small assistant that answers questions from a single prompt does not need this. One plain chat call is simpler, cheaper, and easier to test. Reaching for a multi-agent framework to answer a FAQ is like hiring a team to carry one box. The tool is good, and the job is too small for it.
Teams already running AutoGen in production should plan the move, not rush it. Read the migration guide, map one small agent first, and run the old and new systems side by side until the new one passes your own checks. A rewrite done overnight is how working systems break.
Teams with a working system on LangGraph or CrewAI have no reason to switch for its own sake. A framework change is a real cost, and it only pays off when the new tool solves a problem the old one cannot. If your current stack works and your team knows it, stay where you are.
Microsoft Agent Framework vs LangGraph vs CrewAI
Three frameworks dominate this conversation, and they are not the same tool with different logos. The table below compares them on the things that actually decide a choice. There are no benchmark numbers here, because the comparison pages disagree on method and no authority-grade test covers all three on the same task.
| Framework | Control model | Languages | Best fit |
|---|---|---|---|
| Microsoft Agent Framework | Graph workflows plus an opinionated harness agent | Python and .NET, Go in preview | Teams on the Microsoft stack building production multi-agent systems |
| LangGraph | Explicit graph control over state and steps | Python first, JavaScript as well | Teams that want full control of state and every step of an agent's path |
| CrewAI | Role-based crews of agents with defined jobs | Python | Small teams that want a working multi-agent setup quickly |
LangGraph gives you the most control. You define the graph, the state, and every transition, and nothing happens that you did not draw. That control is the reason teams pick it, and it is also the reason it takes longer to build with. It fits teams who need to prove exactly what their agents did, step by step. We compared the two directly in our LangGraph vs AutoGen guide.
CrewAI is the fastest to start with. You describe agents by role, give them a goal, and let the crew work. It fits prototypes and small teams, and it fits projects where the shape of the work is a team of specialists rather than a strict pipeline.
Our CrewAI vs LangGraph comparison covers both frameworks in more depth. The enterprise machinery the Agent Framework carries is mostly absent here, and for many projects that is fine.
The Agent Framework sits between them on control and ahead of both on Microsoft integration. If your models, identity, and hosting already live in Azure and Foundry, it removes work that the other two leave to you. When your stack lives elsewhere, that advantage disappears, and the choice comes down to language and control.
Moving From AutoGen or Semantic Kernel
Migration is a project, not an afternoon, and it goes better in small steps.
First, read Microsoft's AutoGen to Microsoft Agent Framework migration guide on Learn. It maps the pieces one by one: model clients, single agents, multi-agent workflows, and observability. Read it before you touch any code, because it tells you which AutoGen ideas have a direct match and which ones need rethinking.
Second, map one small agent first, not the whole system. Pick an agent with few tools and no strange dependencies. Build its match in the new framework, run the same prompts through both, and compare the answers. The differences you find here teach you what the rest of the move will cost.
Third, move tools and prompts as they are. A tool is a function with a description, and that idea carries over unchanged. Do not rewrite prompts and tools in the same step as the framework move. One change at a time keeps failures easy to trace.
Fourth, rebuild multi-agent flows as graph workflows rather than copying the old conversation patterns. AutoGen let agents talk freely, and that freedom hid problems. A graph makes the path explicit, and explicit paths are easier to test, to trace, and to fix.
Fifth, run both systems side by side until the new one passes your own checks. Keep the old one live while the new one proves itself on real traffic. Retire the old system only after the new one has handled the work you actually do, not just the examples in the guide.
Semantic Kernel users follow the same shape, with Microsoft's Semantic Kernel migration guide as the map. The work is smaller in most cases, because the enterprise ideas carry over directly, and the main change is the workflow engine and the harness agent.
Frequently Asked Questions
What is the Microsoft Agent Framework?
It is Microsoft's open-source SDK for building AI agents and multi-agent workflows in Python and .NET. It is the direct successor to AutoGen and Semantic Kernel, built by the same teams. Version 1.0 shipped on 3 April 2026 with stable APIs and a long-term support commitment.
Is AutoGen discontinued?
Yes, in effect. Its repository carries an archived notice, and Microsoft provides no bug fixes, security fixes, new features, or support for it. The code stays online for reference, and running systems keep working, but new projects should start with the Microsoft Agent Framework instead.
Is Semantic Kernel dead?
No. It still ships releases, and its .NET package reached 1.81.0 on 6 October 2026. Microsoft positions the Agent Framework as its successor for new work, and it publishes a migration guide, but Semantic Kernel code keeps running and no end date has been announced.
Is Microsoft Agent Framework free?
Yes. It is MIT-licensed open source, so there is no licence price and no per-seat fee. You pay only your model provider for the tokens your agents use, whether that provider is Azure OpenAI, OpenAI, Anthropic, Foundry, or a local model.
Does it support Python and .NET?
Yes, both with consistent APIs, so the same agent ideas work in either language. Go is in public preview in a separate repository, microsoft/agent-framework-go. Do not plan a production Go system on it yet, because preview status means the APIs can still change.
Should I migrate my AutoGen code now?
For new production work, yes, start with the Agent Framework. A running AutoGen system needs a plan instead: work through Microsoft's guide rather than rewriting overnight. Map one small agent first, run both systems side by side, and retire the old one only after the new one passes your checks.
The Decision in Brief
If you are starting a new agent project and your stack is Microsoft's, start with the Agent Framework. On AutoGen, stop starting new work there and plan the move, because the archived repository will not get fixes.
On Semantic Kernel, finish what you have, and start the next project on the new framework. When your current stack works and sits outside Microsoft's world, there is no reason to move. The framework is good, and it is not the only good answer.
Choosing the wrong framework is not the real risk. The real mistake is picking any framework, including this one, without knowing what it replaces and why.






No Comment! Be the first one.