In April 2026, Microsoft did something that surprised a lot of people who’d been keeping tabs on both AutoGen and Semantic Kernel: they merged them. Microsoft Agent Framework 1.0 combines both projects into a single SDK, with one API surface, one set of abstractions, and one roadmap. If you’ve been using either framework in production, this affects you. If you’ve been deciding between them, the decision has been made for you.

Here’s the thing — this was probably the right call. AutoGen and Semantic Kernel had been solving overlapping problems from different directions for two years, and the duplication was creating confusion for enterprise teams trying to pick a stack. AutoGen came from Microsoft Research with a focus on multi-agent systems and conversation-based orchestration. Semantic Kernel came from the product side, built around plugins and memory connectors for production deployment. Both had active communities. Both were pulling resources. Merging them makes sense.

What Microsoft Agent Framework 1.0 Actually Is

The merged framework takes what each predecessor did best. From AutoGen: the multi-agent conversation model, the ability to define agent roles and have them collaborate through message passing, and the research-quality reasoning patterns that came out of Microsoft Research. From Semantic Kernel: the plugin system for connecting to external tools and services, the memory abstractions for retrieval and context, and the enterprise deployment patterns including logging, telemetry, and security hooks.

The result is a framework built around the concept of a runtime — a managed execution environment where agents register, exchange messages, and subscribe to events. This is a meaningful shift from both predecessors. AutoGen had conversations. Semantic Kernel had kernels and planners. The new runtime abstraction is cleaner: it’s closer to an actor model, where agents are independent entities that communicate asynchronously.

from microsoft_agent_framework import AgentRuntime, Agent, tool

runtime = AgentRuntime()

@runtime.agent
class ResearchAgent(Agent):
    @tool
    async def search_web(self, query: str) -> str:
        # Tool implementation
        ...

    async def run(self, task: str):
        results = await self.search_web(task)
        await self.publish("research_complete", results)

@runtime.agent
class SummaryAgent(Agent):
    @runtime.subscribe("research_complete")
    async def on_research(self, results: str):
        summary = await self.model.complete(f"Summarise: {results}")
        return summary

await runtime.run("What are the latest developments in AI security?")

The message-passing model makes multi-agent coordination more explicit. Instead of agents calling each other directly (which creates tight coupling and makes testing painful), agents publish events and subscribe to them. This is a meaningful architectural improvement over how both AutoGen and Semantic Kernel handled agent coordination.

What Migrating From AutoGen Looks Like

If you’ve got AutoGen code, the migration is substantial but not catastrophic. The core concepts map across:

AutoGen’s ConversableAgent becomes a runtime.agent decorated class. The GroupChat pattern from AutoGen — where multiple agents collaborate in a shared conversation — maps to event subscriptions in the new framework. You publish to a topic, and any agent subscribed to that topic responds.

The main effort is restructuring your agent definitions and updating how you handle tool calling. AutoGen used a JSON function-calling format that you registered on agents. The new framework uses decorated methods with type annotations, which is cleaner to write and easier to test.

AutoGen’s built-in code execution (the feature where agents could write and run Python code in a sandboxed environment) is preserved and improved. The runtime now supports E2B and Daytona as execution backends, meaning you get proper cloud sandboxing instead of local subprocess execution.

What Migrating From Semantic Kernel Looks Like

The Semantic Kernel plugin system ports across directly — your plugins become tools registered on agents. The ISemanticTextMemory interface has been replaced with a unified memory API that supports the same backends (Azure AI Search, Qdrant, Chroma, etc.) but with a more consistent interface.

Planners are the trickiest bit. Semantic Kernel’s sequential and stepwise planners had fairly specific behaviour that enterprise teams built workflows around. The new framework doesn’t have a separate planner concept — agents plan through their reasoning loop, optionally guided by structured output schemas. If you relied heavily on SK planners, you’ll need to redesign those workflows.

Should You Migrate Now?

For greenfield projects: yes, start with Microsoft Agent Framework 1.0. It’s the supported path, the documentation is comprehensive, and you won’t be building on something that’s about to be deprecated.

For existing AutoGen projects: migration is worthwhile if your codebase is under active development. If you’ve got a stable, working system that you maintain rather than develop, there’s no pressing reason to migrate today. Microsoft has committed to security patches for AutoGen 0.4 until January 2028.

For existing Semantic Kernel projects: same calculus. Active development warrants migration. Stable maintenance-mode systems can wait.

What’s Genuinely Better

The runtime model is a genuine improvement for complex multi-agent systems. Being able to reason about your agents as event-driven actors — what events they produce, what events they consume — makes the system easier to design, test, and debug. This is particularly valuable when you’re building systems where the interaction patterns between agents are complex or dynamic.

The unified memory API is also better than either predecessor. Instead of different memory backends having different interfaces in SK and AutoGen essentially not having a production memory story at all, you’ve got one API that works consistently across providers.

Whether you agree with the merger decision or not, Microsoft Agent Framework 1.0 is a more coherent framework than either AutoGen or Semantic Kernel was on its own. For enterprise teams building production agentic systems, coherent matters.