Semantic Kernel + AutoGen = Microsoft Agent Framework -- What It Means for M365 Developers

If you’ve been building with Semantic Kernel for the past year, you probably had a moment where you looked at AutoGen and thought: “Wait, should I be using that instead?” And if you started with AutoGen for multi-agent scenarios, you probably hit a wall and thought: “I wish this had Semantic Kernel’s production features.”

Microsoft heard both of those. On October 1st, they announced the Microsoft Agent Framework – a new open source framework that merges Semantic Kernel and AutoGen into a single SDK. Microsoft’s official Foundry blog post covers the vision, and Visual Studio Magazine picked it up the same day. It’s in public preview now, with 1.0 GA targeted for end of Q1 2026.

Let me break down what this means and what you should actually do about it.

Why Microsoft merged two frameworks into one

Here’s the honest version: having two AI agent frameworks from the same company was confusing. Semantic Kernel was the enterprise grade, production ready SDK – good for building single agents with plugins, function calling, and telemetry. AutoGen came out of Microsoft Research and was the multi-agent pioneer – great for orchestrating conversations between multiple AI agents.

The problem? Developers kept having to choose. Or worse, they tried to glue both together. Microsoft’s own blog post summed it up: developers asked “why can’t we have both – the innovation of AutoGen and the trust and stability of Semantic Kernel – in one unified framework?”

So they built exactly that. Shawn Henry’s Semantic Kernel blog post lays out the official transition plan and support commitments in detail.

What the Microsoft Agent Framework looks like

The new framework is open source under the MIT license, supports Python and .NET (C#), and lives at github.com/microsoft/agent-framework.

It brings together AutoGen’s agent abstractions (the composable agent model that made multi-agent patterns accessible), Semantic Kernel’s enterprise backbone (session based state management, type safety, middleware pipelines, OpenTelemetry observability), and a new graph based workflow orchestration system that lets you define explicit multi-agent workflows instead of relying on free form agent conversations.

There are two orchestration modes:

1. Agent Orchestration – LLM-driven, where the model decides which agent handles what. Good for creative reasoning and open ended problem solving.
2. Workflow Orchestration – deterministic, business logic driven flows where you define exactly which agent does what and when. Good for enterprise processes that need predictability.

You also get built-in support for MCP (Model Context Protocol), A2A (Agent-to-Agent) messaging, and OpenAPI-first design. Pluggable memory backends are included – Redis, Pinecone, Qdrant, Weaviate, Elasticsearch, and Postgres all work out of the box.

And then there’s human-in-the-loop approval workflows and long-running durability with pause and resume. Those are the kinds of features you actually need for enterprise deployments, not just demos.

The timeline: what happens to Semantic Kernel and AutoGen

Here’s the part that matters if you have existing code.

Semantic Kernel v1.x enters maintenance mode. Microsoft will keep shipping critical bug fixes and security updates for at least one year after the Agent Framework reaches GA. Some Semantic Kernel features that were in preview will still get promoted to GA. But new feature development goes to the Agent Framework.

AutoGen follows a similar path. It stays open source and will get critical fixes, but all new investment goes into the Agent Framework.

Microsoft is positioning the Agent Framework as basically “Semantic Kernel v2.0” – same team, same philosophy, just with AutoGen’s multi-agent stuff folded in.

The GA target is end of Q1 2026. The framework has already reached Release Candidate status for both .NET and Python, so the API surface is considered stable. Breaking changes should be minimal from here.

Impact on your existing Semantic Kernel projects

If you’re running Semantic Kernel in production today: relax. Nothing breaks. Your code keeps working, and you’ll keep getting security patches.

But you should start thinking about migration. Microsoft has published official migration guides for both .NET and Python on the Agent Framework GitHub repo. The gist: you’ll replace Kernel and plugin patterns with the new Agent and Tool abstractions. The concepts map pretty cleanly – if you know how Kernel and plugins work, Agent and Tool will feel familiar.

Here’s Microsoft’s own guidance on what to do right now:

• Existing production projects: keep running on Semantic Kernel. No rush.
• New projects that need to ship fast: you can still start with Semantic Kernel. It works, it’s stable, it’s documented.
• New projects with flexible timelines: start with the Agent Framework. Get ahead of the curve.
• New projects that need multi-agent orchestration: definitely start with the Agent Framework. This is the reason the framework exists.

Impact on your AutoGen multi-agent scenarios

If you were using AutoGen, the migration is actually pretty smooth. The Agent Framework’s single-agent interface is almost identical to AutoGen’s AssistantAgent. You map that to the new ChatAgent, and you get conversation thread management, middleware, and hosted tools on top.

The biggest change is the workflow API. If you had complex multi-agent orchestration in AutoGen, you’ll want to look at the new graph based workflow system. It’s more explicit and more powerful than AutoGen’s conversational patterns, but it does require rethinking how your agents coordinate.

How this fits the M365 Copilot extensibility stack

The M365 crowd should pay attention here.

If you’re building Custom Engine Agents for Microsoft 365 Copilot – the pro-code path where you bring your own orchestration – the Agent Framework is now the recommended foundation. It goes where Semantic Kernel or LangChain used to sit: your orchestration layer that handles tool calling, agent logic, and LLM interactions, while the M365 Agents SDK handles the channel integration (Teams, Outlook, Copilot surface).

Microsoft has been explicit about the convergence plan: the Agent Framework, the M365 Agents SDK, and Azure AI Foundry Agent Service are heading toward one unified set of abstractions for building, deploying, and publishing agents across Microsoft 365 Copilot and other channels.

For Declarative Agents (the config-as-code approach), this doesn’t change much. Those still run on Microsoft’s orchestrator. But if you’re hitting the ceiling of what declarative agents can do and you’re thinking about the jump to custom engine agents, the Agent Framework is a better starting point than raw Semantic Kernel was.

What to build now vs. wait for 1.0

My practical advice:

If you’re starting something new that doesn’t need to ship until Q1 2026 or later, go with the Agent Framework. Same if you need multi-agent orchestration or you’re building a custom engine agent for M365 Copilot. That’s where the investment is going.

If you have something in production on Semantic Kernel that works, leave it alone. If you need to ship in the next two months, Semantic Kernel is still fine – it’s stable and well documented. Single agent with plugins? Semantic Kernel handles that perfectly well today.

If your organization won’t touch anything that isn’t GA, just wait.

The RC status means the API is stable. I wouldn’t be nervous about building on it for projects targeting early 2026 delivery. But if your CTO needs “generally available” on the label before signing off, that’s fair – Q1 2026 isn’t far.

Looking ahead

I think this merger was the right call. The two-framework confusion was a real problem in the community, and having one framework with clear upgrade paths is what the Microsoft AI developer story needed.

The bigger picture is that Microsoft now has a clearer stack: Agent Framework for building agent logic, Azure AI Foundry for hosting and observability, M365 Agents SDK for distribution. I can actually draw that on a whiteboard without running out of space, which is more than I could say six months ago.

Keep an eye on the Agent Framework GitHub repo and the migration guides as they evolve. And if you’re at Ignite in November, I’d expect Microsoft to have a lot more to say about this.

Read more

• Introducing Microsoft Agent Framework – Microsoft Foundry Blog – the official launch announcement covering the four pillars and migration snippets
• Semantic Kernel and Microsoft Agent Framework – Shawn Henry – Microsoft’s position on the transition, support timeline, and what to do with existing projects
• Semantic Kernel + AutoGen: Open Source Microsoft Agent Framework – Visual Studio Magazine – news coverage with a .NET developer angle
• microsoft/agent-framework on GitHub – the source code, samples, and migration guides
• Migrate Your Semantic Kernel and AutoGen Projects – Microsoft DevBlogs – step-by-step migration documentation for .NET and Python