Microsoft Agent Framework 1.0 for Product Managers: What the AutoGen and Semantic Kernel Merger Changes
TL;DR
On April 3, 2026, Microsoft shipped Agent Framework 1.0, merging AutoGen (multi-agent orchestration) and Semantic Kernel (enterprise LLM integration) into one production-ready SDK for .NET and Python. The unified framework ships with a browser-based DevUI for real-time agent debugging, native MCP and A2A protocol support, and a plugin architecture that carries forward from Semantic Kernel. For product managers at companies with Azure infrastructure or .NET stacks, this is now the default enterprise agent framework. For everyone else, it is the benchmark to compare alternatives against.
The AI PM Minute
One tactic to make you a sharper AI PM, twice a week. 60 seconds to read. Free.
No fluff. Unsubscribe anytime.
What Happened: Two Frameworks, One SDK
Microsoft had been developing two agent frameworks in parallel since 2023, each with a distinct design philosophy and a distinct audience.
AutoGen
Microsoft Research, 2023Strength: Experimental multi-agent orchestration. Excelled at defining patterns for agents to collaborate: group chats, sequential workflows, debate loops, and hierarchical task delegation.
Weakness: Research-oriented defaults. Production hardening was left to the user. Enterprise integration (authentication, plugin management, monitoring) required significant custom work.
Semantic Kernel
Microsoft product team, 2023Strength: Enterprise-grade LLM integration via a plugin architecture. Strong support for authentication, memory, planners, and safe function calling. Favored by enterprise teams building on Azure OpenAI.
Weakness: Multi-agent orchestration was bolted on rather than native. Complex multi-agent patterns required more boilerplate than AutoGen's research-first primitives.
The practical consequence: teams kept picking one and then hitting the wall that required the other. AutoGen teams wanted Semantic Kernel's enterprise plugin model. Semantic Kernel teams wanted AutoGen's multi-agent patterns. Microsoft ran a public preview of the merged framework in October 2025, collected feedback, and shipped the 1.0 GA on April 3, 2026.
The merged SDK is available for .NET and Python. It works with any OpenAI-compatible model endpoint, not just Azure OpenAI. The package names changed at GA; teams migrating from either predecessor framework need to update their imports and review the migration guide.
How the Unified Framework Works
The framework is built around two core primitives: the Kernel and the Agent. The Kernel manages model integration, plugin registration, and service configuration. Agents use the Kernel to call models and tools. This separation lets you configure the LLM, memory, and telemetry layer once and reuse it across multiple agents.
Plugin system
Carries forward from Semantic Kernel. A plugin bundles a set of functions (tools) with their descriptions and schemas. Plugins are registered with the Kernel and become available to any agent that uses that Kernel. This makes reuse and testing straightforward.
Multi-agent orchestration
Carries forward from AutoGen. You define agent roles and communication patterns: sequential, group chat, hierarchical. The framework handles turn management, message routing, and termination conditions.
Planner integration
The Kernel can call a planner to decompose a complex task into a sequence of plugin calls. Useful for open-ended user requests where the agent needs to figure out the execution path, not just follow a predetermined one.
Memory and context
Built-in memory connectors for vector databases and key-value stores. Agents can retrieve relevant context before responding. The memory layer is configurable and swappable without changing agent logic.
The DevUI: What It Changes for PM-Engineering Collaboration
The DevUI is the new addition in the 1.0 GA release. It is a browser-based debugger that renders the agent's execution in real time: message flow between agents, tool calls and their results, decision points, and timing. You run the local development server, open a browser, and see exactly what the agent is doing and why.
This matters for product managers because it changes the nature of sprint demos and debugging conversations. Previously, understanding why an agent produced a specific output required reading raw logs or asking engineering to add instrumentation. With the DevUI, the execution trace is visual and navigable.
Sprint demos
You can show stakeholders not just what the agent produced, but the reasoning path it took. This makes agent behavior legible to non-technical audiences and reduces the 'magic box' perception that slows down sign-off.
Failure diagnosis
When an agent produces a wrong or unexpected output, the execution trace shows exactly where the deviation happened. You can identify whether the failure is at the tool call, the model response, or the orchestration layer without needing engineering to reproduce the state.
Spec validation
The DevUI lets PMs verify that agent behavior matches the spec before a feature is considered done. Does the agent actually escalate when it should? Does it call the right tools in the right order? These are testable via the trace.
Guardrail tuning
Seeing exactly where an agent stops, escalates, or refuses helps you tune the guardrail logic without guesswork. The trace makes policy decisions visible, not just their outputs.
Learn to Evaluate Agent Frameworks Like an Expert
The AI PM Masterclass covers how to evaluate and select agent infrastructure, write agentic product specs, and make framework decisions that your engineering team can actually execute. Taught live by a Salesforce Sr. Director PM.
Protocol Support: MCP and A2A Built In
Two interoperability protocols reached critical mass in 2026: Model Context Protocol (MCP) for agent-to-tool communication and Agent-to-Agent (A2A) for agent-to-agent communication. Microsoft Agent Framework 1.0 ships with native support for both. This is a significant product decision: it means your agents can connect to the ecosystem of 200+ MCP servers and communicate with agents built on other frameworks using A2A, without custom integration work.
MCP: connect to any tool
MCP is the emerging standard for how agents discover and call external tools: databases, APIs, file systems, code execution environments. Native MCP support means your agent can connect to any MCP server without writing a custom plugin. The ecosystem of available MCP servers was over 200 implementations as of mid-2026.
A2A: agents talking to agents
A2A (formerly ACP, now merged into A2A under the Linux Foundation) defines how agents from different frameworks and providers communicate. Native A2A support means your Microsoft Agent Framework agents can coordinate with agents built in LangGraph, Claude Agent SDK, or any other A2A-compliant framework.
Product implications of MCP
Your plugin design scope narrows significantly. Instead of building custom integrations for every tool, you define an MCP server once and it works with any MCP-compatible agent. This changes the make-vs-buy calculus on integrations.
Product implications of A2A
You can design multi-agent workflows that span frameworks and vendors. An orchestrating agent in Azure can delegate to a specialist agent running on a different provider, with A2A handling the coordination protocol.
When to Choose Microsoft Agent Framework
The framework is not the right default for every team. Here is how to evaluate it against your context.
Strong fit: Azure and Microsoft infrastructure shops
If your engineering team already uses Azure OpenAI, Azure AI Foundry, or deploys on Azure, the framework's deep integration with those services reduces setup friction significantly. Authentication, telemetry, and deployment tooling are all first-class.
Strong fit: Enterprise .NET product teams
The .NET SDK is production-grade and well-suited to teams with existing C# codebases. Enterprise features like authentication flows, audit logging, and compliance tooling are built in rather than bolted on.
Strong fit: Teams that need multi-agent patterns immediately
If your product requires more than one agent collaborating from day one, the framework gives you tested orchestration patterns out of the box. You don't spend a sprint building the plumbing before you can test the product.
Weaker fit: Python-first teams on non-Azure infrastructure
If your stack is Python-only and you are not on Azure, alternatives like Pydantic AI V2 (tighter Python typing, lighter dependency footprint) or Claude Agent SDK (Anthropic-native, strong MCP integration) may be a better fit for your team's defaults.
Weaker fit: Startups optimizing for iteration speed over enterprise guarantees
The framework carries enterprise abstractions that add learning curve. For a two-engineer startup shipping a first agent product, simpler options with less surface area get you to production faster.
The three questions to answer before committing: Is your infrastructure on Azure? Is your engineering team .NET or Python? Does your product require multi-agent orchestration from the start, or can you start with a single-agent pattern and expand? Two or more yes answers make Microsoft Agent Framework 1.0 the logical default.
Make Framework Decisions That Hold Up in Production
The AI PM Masterclass teaches you how to evaluate agent infrastructure, translate technical tradeoffs into product decisions, and write specs your engineering team can execute. Taught live by a Salesforce Sr. Director PM.
Related Articles
Before you go: get the AI PM Minute
One tactic to make you a sharper AI PM, twice a week. 60 seconds to read. Free.
No fluff. Unsubscribe anytime.