Konstantin Semenenko
July 29, 2026
4
minutes read
Microsoft Agent Framework is the official .NET stack for agents now, and Semantic Kernel is finished getting new features. For any new agent project the answer is Agent Framework, full stop, because Semantic Kernel will never get the orchestration, durable execution, or native MCP and A2A that Agent Framework has. And if you are already on Semantic Kernel and hitting its limits, this is not a migration to keep deferring: every month on a frozen framework is a month building around ceilings Microsoft has decided not to raise. New work goes on Agent Framework; existing work at the edge of what SK can do should move now.
If you are choosing a .NET agent framework in 2026, the decision is already made for you: Microsoft Agent Framework. It reached GA in April 2026 as the unification of Semantic Kernel and AutoGen, and it is where all of Microsoft's agentic investment now goes. Semantic Kernel, by contrast, is in maintenance, it still runs, it still gets critical fixes, but it is done getting new capabilities. That single fact settles the question for new projects. There is no scenario where starting a new agent system on a framework that will never gain another feature beats starting it on the one Microsoft is actively building. And for teams already on Semantic Kernel who are pushing against its limits, the same fact turns migration from a someday-task into a now-decision. This is the direct version of the argument, and the direct recommendation.
We build .NET agent systems on Microsoft Agent Framework, and we migrate teams off Semantic Kernel, so this is our actual recommendation, not a neutral survey.
Everything here follows from a single point, so start with it plainly: Semantic Kernel will not get new features. When Microsoft Agent Framework reached GA, Semantic Kernel moved into maintenance mode, which means critical fixes continue but feature development stops. Microsoft consolidated its two agent frameworks, Semantic Kernel and AutoGen, into one, and that one is Agent Framework. The investment, the roadmap, and the new capabilities are all on the Agent Framework side of the line now.
That is not a criticism of Semantic Kernel, it did its job and much of it lives on inside Agent Framework, but it is decisive for anyone making a choice today. A framework that has stopped evolving is a poor foundation for something new, because you are building on a base that is frozen at exactly the moment agent tooling is moving fastest. Native MCP, native A2A, durable execution, unified multi-agent orchestration, these are in Agent Framework and they are not coming to Semantic Kernel, ever. So the question "which should I start a new project on" does not actually have two answers. It has one, and the rest of this explains why that holds for new work and what it means for existing work.
For anything new, build on Agent Framework, and the reasoning is simple enough that the exceptions people reach for do not survive it. The instinct to start on Semantic Kernel usually comes from familiarity, a team knows it, has used it, finds it comfortable. That is a real feeling and a bad reason, because comfort with a frozen framework is a depreciating asset: every month, Agent Framework gains and Semantic Kernel does not, so the gap you are choosing to sit behind only widens.
The capabilities make it concrete. Agent Framework gives you unified orchestration patterns (sequential, concurrent, handoff, group chat), durable execution and checkpointing for long-running workflows, and native MCP and A2A support, the standards we cover in MCP explained and A2A explained. Starting a new project on Semantic Kernel means either doing without those or building them yourself, to end up with a worse version of what Agent Framework ships. There is no new-project scenario where that trade makes sense. Whatever you were going to build on Semantic Kernel, build it on Agent Framework, which sits on the same Microsoft.Extensions.AI foundation, so the base you already know carries over, the layer we cover in Microsoft.Extensions.AI explained.
Here the recommendation splits honestly, because not every existing system needs to move tomorrow, and pretending otherwise would be the kind of manufactured urgency that does not survive contact with a real engineering team. A Semantic Kernel system that works, does everything you need, and is not straining against the framework's limits does not have to be migrated this quarter. It keeps running, it keeps getting critical fixes, and there is no emergency. If that is you, plan the migration deliberately rather than dropping everything.
But if you are on Semantic Kernel and hitting its ceiling, wanting better multi-agent orchestration, needing durable execution for long-running workflows, wanting native MCP or A2A instead of hand-rolling it, then the calculus is different, and the honest word is: do not keep deferring it. Every month you spend building workarounds for capabilities Semantic Kernel will never gain is a month invested in a dead end, when the same effort put into migration buys you a foundation that keeps improving. That is the real urgency, and it is specific: not "everyone must flee Semantic Kernel," but "if you are fighting its limits, stop building around them and migrate to the framework that removes them." The mechanics of doing that cleanly are in how to migrate from Semantic Kernel to Microsoft Agent Framework.
The reason the recommendation is easy to act on is that moving off Semantic Kernel is not the painful rebuild it sounds like, because the two frameworks share a foundation. Both are built on Microsoft.Extensions.AI, so the layer where your code connects to models carries over largely unchanged, and the core concepts, agents, tools, function calling, exist in both with different APIs rather than different ideas. Your non-AI code is untouched entirely.
So the migration concentrates in the agent and orchestration layers, and it is mostly translation plus a deliberate rebuild of orchestration into Agent Framework's stronger model, which is where you gain the durable execution and multi-agent patterns you migrated to get. Done incrementally, one agent at a time with verification at each step, you keep a working system throughout. That containment is what makes "migrate if you're at the ceiling" a realistic instruction rather than a scary one: you are not rewriting your application, you are moving the agent layer onto a foundation that will keep getting better.
The decision, reduced to steps:
Microsoft Agent Framework is the official .NET agent stack now, and Semantic Kernel is done getting new features, and those two facts settle the decision. For any new project, build on Agent Framework, full stop, because starting new work on a frozen framework that will never gain native MCP, A2A, durable execution, or improved orchestration is a choice that only ages worse. For existing Semantic Kernel systems, be honest about which situation you are in: a working system that is not straining can migrate on your schedule, but a system hitting Semantic Kernel's limits should migrate now rather than accumulate workarounds for capabilities that are never coming. And because both frameworks share the Microsoft.Extensions.AI foundation, migrating is an evolution, not a rewrite, which is what makes acting on this straightforward.
If you are starting a new .NET agent project or you are on Semantic Kernel and feeling its limits, that is worth a conversation. Book a 15-minute call and we will give you a straight read on whether to build new or migrate, and how.
Should I use Semantic Kernel or Microsoft Agent Framework for a new project? Microsoft Agent Framework, without exception. Semantic Kernel is in maintenance and will not get new features, so starting new work on it means building on a frozen foundation that will never gain native MCP, A2A, durable execution, or the improved orchestration Agent Framework already has. For anything new, Agent Framework is the answer.
Is Semantic Kernel obsolete? It is in maintenance mode: still running, still receiving critical fixes, but done getting new features. It is not removed or broken, and existing systems keep working. But because all new capability now goes into Microsoft Agent Framework, Semantic Kernel is no longer the framework to build new systems on.
Do I need to migrate off Semantic Kernel immediately? It depends on your situation. A working system that is not straining against Semantic Kernel's limits does not need an emergency migration, plan it deliberately. But if you are hitting its ceiling and building workarounds for features it will never gain (better orchestration, durable execution, MCP, A2A), migrate now rather than keep investing in a dead end.
Is migrating from Semantic Kernel to Agent Framework a full rewrite? No. Both build on the same Microsoft.Extensions.AI foundation, so your model-access layer and non-AI code largely carry over, and core concepts (agents, tools, function calling) are preserved with changed APIs. The work concentrates in the agent and orchestration layers, and done incrementally it keeps a working system throughout.
Why did Microsoft move away from Semantic Kernel? It did not abandon it so much as consolidate. Microsoft had two overlapping agent frameworks, Semantic Kernel and AutoGen, and unified them into Microsoft Agent Framework, which combines Semantic Kernel's enterprise foundations with AutoGen's orchestration. Semantic Kernel's role is now the maintained predecessor; new investment goes into Agent Framework.
