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.
| Aspect | AutoGen (Pre-Merger) | Semantic Kernel (Pre-Merger) | Agent Framework 1.0 |
|---|---|---|---|
| Origin | Microsoft Research | Azure SDK team | Unified team |
| Strength | Multi-agent conversations | Enterprise integration | Both |
| Agent Model | Multi-agent, flexible | Single-agent, structured | Multi-agent, structured |
| Enterprise Readiness | Low (research project) | High (production SDK) | High |
| Azure Integration | Minimal | Deep (AD, Key Vault, etc.) | Deep |
| Languages | Python | .NET, Python | .NET, Python |
| Maturity | Experimental | Production | Production (1.0) |
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:
| Primitive | Description | Use Case |
|---|---|---|
| Agent Definitions | Configurable roles, capabilities, tool access | Specialized agent personas |
| Conversation Patterns | Round-robin, hierarchical, custom topologies | Team coordination strategies |
| Delegation Protocols | Subtask assignment to specialized agents | Divide-and-conquer workflows |
| Orchestration Strategies | Lifecycle management, resource allocation | Production agent coordination |
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:
| Provider | Models | Best For |
|---|---|---|
| Azure OpenAI | GPT-5.x | Enterprise-grade, Azure-integrated |
| OpenAI Direct | GPT-5.x | Direct access without Azure |
| Anthropic | Claude 4.6 | Deep reasoning tasks |
| Gemini 3 | Large context, multimodal | |
| Azure AI | Open-source models | Cost optimization, privacy |
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:
| Framework | Strengths | Weaknesses | Best For |
|---|---|---|---|
| Microsoft Agent Framework | Enterprise integration, multi-provider, A2A+MCP | .NET/Python only, heavier | Azure enterprises |
| Claude Agent SDK | Deep reasoning, built-in tools, production-ready | Claude models only | Agent apps, conversational AI |
| LangGraph | Flexible graph workflows, streaming, checkpointing | Steeper learning curve | Complex multi-step workflows |
| CrewAI | Simple multi-agent setup, role-based | Less enterprise tooling | Rapid prototyping |
| Google ADK | Gemini integration, generous free tier | Newer, smaller ecosystem | Google Cloud teams |
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
