Microsoft Agent Framework 1.0: The Unified SDK That Merges AutoGen and Semantic Kernel

On April 6, 2026, Microsoft released version 1.0 of its unified Agent Framework for .NET and Python — marking the production-ready milestone for a project that spent over a year consolidating two previously separate frameworks: AutoGen (multi-agent conversations from Microsoft Research) and Semantic Kernel (enterprise LLM integration SDK).

The 1.0 release is significant not because Microsoft built another agent framework — the market has plenty — but because it represents the first time a major enterprise vendor has shipped a unified, production-grade SDK that combines multi-agent orchestration with enterprise platform integration in a single coherent programming model.

The Consolidation Story

Understanding the 1.0 release requires understanding what came before it.

AutoGen, developed by Microsoft Research, was an open-source framework for building multi-agent systems where multiple AI agents converse with each other to solve tasks. Its strength was flexibility: you could define agent roles, conversation patterns, and delegation hierarchies. Its weakness was enterprise readiness — AutoGen was a research project, not a platform SDK.

Semantic Kernel was the opposite: an enterprise-grade SDK for integrating LLMs into .NET and Python applications. It provided plugin systems, memory management, and integration with Azure services. Its strength was production deployment. Its weakness was that it treated AI as a single-agent system — one model, one conversation, one task.

Throughout 2024 and early 2025, enterprise teams evaluating Microsoft's AI tooling faced an impossible question: "Should we use AutoGen or Semantic Kernel?" The answer depended on whether they needed multi-agent capabilities (AutoGen) or enterprise platform features (Semantic Kernel), but in practice, most production systems needed both.

The consolidation, announced in mid-2025 and shipped as 1.0 in April 2026, merges AutoGen's multi-agent orchestration into Semantic Kernel's enterprise SDK architecture.

What 1.0 Delivers

Architecture Overview

Enterprise-Grade Multi-Agent Orchestration

The framework provides first-class primitives for building multi-agent systems:

These primitives are built on Semantic Kernel's existing plugin and kernel architecture, meaning they integrate naturally with enterprise infrastructure — Azure AD authentication, Key Vault for secrets, Application Insights for monitoring.

Multi-Provider Model Support

Unlike Claude Code (Claude-only) or Gemini CLI (Gemini-only), Microsoft's framework supports multiple model providers from the same SDK:

This multi-provider support enables architectures where different agents in the same system use different models optimized for different tasks. A planning agent might use GPT-5.4 for strategic reasoning while execution agents use smaller, faster models for routine operations.

Cross-Runtime Interoperability via A2A and MCP

The framework supports two interoperability protocols:

A2A (Agent-to-Agent) — Google's protocol for agent-to-agent communication, enabling agents built with Microsoft's framework to communicate with agents built with other frameworks. This is particularly relevant for enterprise environments where different teams may use different agent frameworks.

MCP (Model Context Protocol) — Anthropic's protocol for connecting agents to tools and data sources. The framework's MCP support means agents can use the same MCP servers that Claude Code, Cursor, and Gemini CLI connect to.

Supporting both A2A and MCP positions the framework as a polyglot integration point in heterogeneous enterprise environments.

The SDK Programming Model

The framework follows a kernel-based architecture where agents are composed from kernels, plugins, and orchestrators:

from microsoft.agent_framework import Agent, Kernel, ChatCompletion
from microsoft.agent_framework.orchestration import RoundRobinOrchestrator

planner = Agent(
    name="planner",
    kernel=Kernel(
        ai_service=ChatCompletion(model="gpt-5.4"),
        plugins=[planning_plugin, code_review_plugin]
    ),
    instructions="You plan implementation tasks and delegate to specialists."
)

implementer = Agent(
    name="implementer",
    kernel=Kernel(
        ai_service=ChatCompletion(model="gpt-5.2"),
        plugins=[code_generation_plugin, file_system_plugin]
    ),
    instructions="You implement code changes based on plans."
)

orchestrator = RoundRobinOrchestrator(agents=[planner, implementer])
result = await orchestrator.run("Implement user authentication with JWT tokens")

The programming model is deliberately familiar. If you've used Semantic Kernel, the transition is minimal — agents are an extension of kernels, not a replacement. If you're coming from AutoGen, the conversation patterns map to orchestration strategies with more explicit lifecycle management.

How It Compares to the Existing Landscape

The agent framework landscape in April 2026 includes several mature options:

Microsoft's framework differentiates on enterprise integration — Azure AD, Key Vault, Application Insights, and Entra ID are first-class citizens, not afterthoughts. For enterprises already invested in Azure, this integration alone justifies evaluation.

For teams building on platforms like Neumar, which uses Claude Agent SDK for conversational agents and LangGraph for complex workflows, Microsoft's framework is less a replacement than a complement — particularly for enterprise customers who need Azure-native agent deployments.

Consolidation Timeline

What This Means for the Agent Ecosystem

The 1.0 release has three implications for the broader agent development ecosystem:

1. Enterprise Agent Development Has a Default Platform

Before this release, enterprise teams choosing an agent framework had to evaluate multiple options with different maturity levels, integration patterns, and support models. Microsoft's 1.0 provides a default choice for Azure-centric enterprises — not necessarily the best choice for every scenario, but the safe choice that aligns with existing infrastructure investments.

2. Interoperability Protocols Are Becoming Table Stakes

The framework's support for both A2A and MCP signals that interoperability is no longer optional. Agent frameworks that don't support at least one major interoperability protocol will face increasing isolation as the ecosystem standardizes on cross-framework communication.

3. Multi-Model is the Enterprise Pattern

The framework's multi-provider support reflects a growing consensus: production agent systems will use multiple models. The era of single-provider lock-in is ending, at least at the enterprise tier. The question is no longer "which model should we use?" but "which model should each agent in our system use?"

References

• Microsoft Ships Production-Ready Agent Framework 1.0 for .NET and Python — Visual Studio Magazine
• Microsoft Agent Framework Version 1.0 — Microsoft Agent Framework Blog
• Introducing the Agent Governance Toolkit: Open-source runtime security for AI agents — Microsoft Open Source Blog
• Claude Agent SDK Deep Dive: What It Means to Use Claude Code as a Library — DEV Community
• anthropics/claude-agent-sdk-typescript — GitHub