Microsoft spent much of 2023 and 2024 shipping two parallel agent development frameworks that addressed overlapping use cases with different design philosophies: AutoGen, an open-source multi-agent conversation framework from Microsoft Research, and Semantic Kernel, an SDK for integrating large language models into applications with a focus on enterprise .NET and Python ecosystems.
The two frameworks were developed largely independently, maintained separate documentation, had incompatible abstractions for concepts like agents and tools, and offered confusingly similar pitch decks to enterprise customers evaluating AI development options.
In mid-2025, Microsoft announced the consolidation of both frameworks into a unified programming model. The announcement clarified the direction the company was heading, resolved the "which framework should we use?" question that had paralyzed many enterprise evaluation processes, and set the stage for what Microsoft is positioning as the dominant enterprise agent development platform.
What AutoGen and Semantic Kernel Each Brought
Understanding the consolidation requires understanding what each framework was actually good at.
| Feature | AutoGen | Semantic Kernel |
|---|---|---|
| Primary strength | Multi-agent conversation patterns | Enterprise plugin architecture |
| Language focus | Python-centric | .NET, Python, Java |
| Planning model | Conversational planning | Structured planner components |
| Code execution | Strong sandboxed execution | Limited |
| Enterprise integration | Limited tooling | First-class concern |
| Multi-agent collaboration | Core design pattern | Less suited to free-form collaboration |
AutoGen's Strengths
AutoGen's core contribution was the multi-agent conversation pattern: a runtime where multiple agents — each with their own system prompt, tool set, and decision-making logic — could exchange messages to collaboratively complete tasks. The AssistantAgent and UserProxyAgent primitives made it straightforward to create scenarios where agents delegated to each other, challenged each other's outputs, or collaborated on tasks too large for a single agent to handle reliably.
AutoGen also had strong support for code execution: agents could generate Python code, execute it in a sandboxed environment, observe the output, and iterate. For data analysis, prototyping, and automated software engineering tasks, this capability made AutoGen a popular choice in research and early enterprise pilots.
The weaknesses were on the enterprise side: the framework lacked robust support for .NET integration, had limited tooling for managing agent configurations across environments, and was designed around conversation-centric patterns that did not map cleanly to all enterprise workflow categories.
Semantic Kernel's Strengths
Semantic Kernel was designed with enterprise integration as a first-class concern. Its plugin architecture mapped closely to how enterprise teams think about software components: discrete, versioned, unit-testable modules that expose specific capabilities. Plugins could be defined in C#, Python, or Java, integrated with existing enterprise systems, and composed into complex workflows without requiring significant changes to existing application architecture.
Semantic Kernel also had mature support for function calling and planning: the planner components could take a high-level goal and generate a sequence of plugin invocations to achieve it. This was closer to a production-ready planning engine than AutoGen's conversational planning, which worked well in research settings but required more guardrails for enterprise deployment.
The weaknesses were the inverse of AutoGen's: Semantic Kernel was less well-suited to free-form multi-agent collaboration, and its planning capabilities — while solid — were less capable than dedicated planning frameworks on complex, novel task types.
The Unified Framework
Microsoft's unified framework — informally called AutoGen 0.4+ or the "new Semantic Kernel" depending on which team is describing it — brings together the multi-agent runtime from AutoGen with the plugin and planning architecture from Semantic Kernel.
The key changes in the unified model:
Unified agent interface. Both AutoGen agents and Semantic Kernel skills are expressed through the same interface. An agent can consume both Semantic Kernel plugins (for enterprise integrations) and AutoGen-style code execution tools (for research and automation tasks) without switching programming models.
Event-driven messaging. The unified framework replaces AutoGen's sequential turn-taking with an event-driven message bus. Agents subscribe to message types and respond to relevant events, enabling more flexible coordination patterns including parallel execution and asynchronous workflows.
Structured memory. Rather than relying on each agent to manage its own conversation history, the unified framework provides first-class memory services: in-memory storage for working context, vector storage for semantic retrieval, and persistent storage for long-term memory. These are shared across agents in a multi-agent scenario.
Process framework. The new Process Framework allows enterprise developers to define explicit workflow graphs — similar to LangGraph's state machine model — while composing agents into those workflows. This gives the structured workflow capability that many enterprise teams need while preserving the flexibility of the multi-agent runtime for less structured scenarios.
What This Means for Enterprise Evaluation
For enterprise teams that had deferred an agent framework decision while waiting for the Microsoft picture to clarify, the consolidation is genuinely clarifying. A few practical implications:
The AutoGen vs. Semantic Kernel decision is resolved. Teams do not need to pick one and risk obsolescence. The unified framework is the strategic direction, and both communities are being migrated toward it.
Azure integration is a genuine strength. The unified framework has deep integration with Azure AI services, Azure Cognitive Search (for retrieval), and Azure OpenAI. For teams heavily invested in the Azure ecosystem, this integration reduces the infrastructure surface area that needs to be managed separately.
The .NET path is first-class again. AutoGen's Python-centric development model had limited appeal to enterprise .NET teams. The unified framework restores .NET as a first-class language for agent development.
Migration complexity is real. Teams that built significant production systems on either AutoGen or Semantic Kernel will face migration work. The unified framework is not backward-compatible with either predecessor, and the effort required to migrate scales with how much application logic is intertwined with framework-specific abstractions.
The Alternative: Supporting Multiple Agent Backends
Microsoft's consolidation is a bet on a unified programming model. Neumar takes a different approach: rather than standardizing on a single agent framework, the architecture supports multiple agent backends that can be selected based on the requirements of the specific task.
The practical difference is flexibility versus coherence:
The consolidated Microsoft framework offers a single, coherent programming model. Agents, tools, planning, and memory all follow consistent patterns. Teams learn one mental model. Monitoring and observability tooling integrates with a single data model. The tradeoff is that the framework makes significant decisions on your behalf about how agents should be structured.
The multi-backend approach preserves optionality. Claude Agent SDK for conversational, tool-calling agents. LangGraph for complex workflow-based agents with explicit state management. Different task categories can be handled by the backend best suited to them. The tradeoff is coordination overhead: different backends have different observability patterns, different error handling, and different deployment profiles.
For teams with heterogeneous agent workloads — some tasks requiring free-form conversational reasoning, others requiring structured multi-step workflows — the multi-backend approach avoids forcing all tasks through a single model that may be well-suited to some task categories and poorly suited to others.
For teams with more homogeneous workloads — primarily enterprise process automation in Azure-heavy environments — the consolidated Microsoft framework's coherence benefits may outweigh the flexibility cost.
A Note on Vendor Lock-In
The consolidation conversation inevitably surfaces the lock-in question. Both AutoGen and Semantic Kernel were technically open-source, but they were deeply integrated with Azure services and optimized for GPT-4 as the underlying model. The unified framework maintains this character.
Agent frameworks that provide genuine model portability — the ability to swap underlying models without rewriting agent logic — offer structural protection against model vendor lock-in. Abstractions like the provider pattern in Neumar's stack allow Claude, OpenAI, and other model providers to be used interchangeably at the API level, so that changes to model pricing, capability, or availability do not require framework-level changes.
This is not a knock on Microsoft's framework — it is a genuine design tradeoff. Deep Azure integration provides real value in Azure-centric environments. The cost is reduced optionality on model choice.
For teams evaluating agent frameworks in late 2025 and beyond, the Microsoft consolidation resolves the AutoGen vs. Semantic Kernel ambiguity but does not resolve the broader question of how much of your agent stack should be tied to a single cloud provider. That question deserves explicit consideration alongside capability and developer experience.