From AutoGen and Semantic Kernel to Microsoft Agent Framework 1.0
Microsoft spent years running two agent stacks in parallel: AutoGen for multi-agent conversation and research orchestration, and Semantic Kernel for enterprise connectors, plugins, filters, and telemetry. In April 2026 those paths converged into a single production SDK: Microsoft Agent Framework 1.0.
This page explains what was merged, why it happened, and how to think about the unified product before you write code or migrate.
Summary
- Microsoft Agent Framework 1.0 is the successor to both AutoGen and Semantic Kernel: AutoGen-style multi-agent patterns plus Semantic Kernel-style enterprise foundations, with graph workflows on top.
- Insight: Teams no longer choose "research orchestration" or "enterprise kernel." One open-source SDK covers single agents, conversations, typed workflows, middleware, and Azure Foundry integration.
- Key Concepts: Agent, AgentSession, tools, middleware, Workflow, orchestration builders (sequential, concurrent, Magentic), ChatClient providers.
- When to Use: Greenfield multi-agent work on .NET or Python, Azure-centric production agents, and any project still on AutoGen or Semantic Kernel that needs a maintained path.
- Limitations/Trade-offs: APIs are not drop-in identical; AutoGen Teams and Semantic Kernel
Kernelplugins need a deliberate migration. Preview features (DevUI, some hosted tools) may still change - verify at build. - Related Topics: conversational multi-agent patterns, graph workflows, plugins/connectors, AutoGen migration, governance controls.
Foundations
AutoGen pioneered group chat, specialist participants, and event-driven multi-agent experiments from Microsoft Research. It made "agents talking to agents" a first-class programming model.
Semantic Kernel focused on production building blocks: model connectors, plugin/function tools, filters, dependency injection, and observability for enterprise .NET and Python apps. It made agents easier to embed inside governed line-of-business systems.
Microsoft Agent Framework is built by the same core teams as the direct next generation of both products. Official docs describe it as AutoGen's simple agent abstractions plus Semantic Kernel's enterprise features (session-based state, type safety, middleware, telemetry), plus graph-based workflows for explicit multi-agent orchestration.
Version 1.0 (announced April 2026) marks stable APIs and a production support commitment for Python (agent-framework on PyPI) and .NET (Microsoft.Agents.AI on NuGet).
AutoGen and Semantic Kernel agent paths move into maintenance relative to this successor - plan migrations with the official guides rather than freezing forever on the old packages.
AutoGen (conversation / multi-agent research)
\
+--> Microsoft Agent Framework 1.0
/ |
Semantic Kernel +-- Agents + tools + sessions
(enterprise) +-- Middleware / telemetry
+-- Graph workflows + orchestrationsMechanics & Interactions
At a high level the framework exposes three capability groups:
- Agents - LLM-backed units that take instructions, call tools or MCP servers, and return responses via providers (Foundry, Azure OpenAI, OpenAI, and others).
- Harness / long-running helpers - opinionated patterns for multi-step work (planning, context compaction, approvals, observability) when a plain agent loop is not enough.
- Workflows - directed graphs of executors and edges with type-safe routing, checkpointing, streaming, and human-in-the-loop request/response.
Single agents are usually created from a chat client:
# Conceptual shape - verify package/API at build
from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
agent = FoundryChatClient(...).as_agent(
name="HelloAgent",
instructions="You are a friendly assistant. Keep answers brief.",
)
result = await agent.run("What is the largest city in France?")Multi-agent work splits into two styles:
| Style | Mental model | Typical API | Best fit |
|---|---|---|---|
| Conversational / orchestration builders | Turn-based collaboration | SequentialBuilder, ConcurrentBuilder, Magentic | Agent-to-agent chat, round-robin review |
| Graph workflows | Typed data-flow graph | WorkflowBuilder, executors, edges | Fixed business process, fan-out/join, HITL gates |
Semantic Kernel's enterprise DNA shows up as middleware (agent, function, and chat interceptors), sessions for conversation state, pluggable memory/context providers, and first-party connectors into Azure and other model hosts. AutoGen's DNA shows up as multi-agent orchestration patterns (sequential, concurrent, handoff, group-style collaboration, Magentic-One style managers) implemented on the workflow engine rather than a separate Team runtime forever.
MCP and A2A integrations extend tools and cross-runtime collaboration so agents are not locked to in-process functions only. Treat protocol support levels as version-sensitive - verify current matrix at build.
Advanced Considerations & Applications
When to stay on AutoGen briefly: short-lived research prototypes that already work and will not ship to production under long-term support. When to stay on Semantic Kernel briefly: isolated kernel plugins that are not agent-centric and have no migration budget this quarter. When to move now: any production or near-production multi-agent system that needs middleware, checkpoints, Foundry hosting, or a single SDK for .NET and Python.
Architecture still matters more than brand. Agent Framework encodes ReAct-like tool loops inside agents, sequential/concurrent multi-agent patterns, and explicit Plan-and-Execute style graphs via workflows. Choose conversation when the path is open-ended; choose workflows when the process is a known graph with audit requirements.
| Inheritance | What you keep in spirit | What changes in practice |
|---|---|---|
| AutoGen | Multi-agent roles, group chat ideas, Magentic orchestration | Teams → workflows/orchestration builders; tools and sessions re-bound |
| Semantic Kernel | Plugins as tools, filters → middleware, enterprise hosting | Less Kernel-centric boilerplate; agent creation via chat clients |
| New in AF | Graph workflows, unified middleware, checkpoint/HITL | Explicit data-flow control beyond free-form chat |
Cost and ops: multi-agent runs multiply model calls. Use sessions carefully, log workflow events, and put policy in middleware so prompts alone do not carry compliance.
Common Misconceptions
- "AutoGen and Semantic Kernel are deleted overnight." They remain reference points and migration sources; Agent Framework is the supported forward path for agent work.
- "1.0 means every sample from RC still compiles." 1.0 is production-ready, but you should still re-verify client names, package extras, and orchestration imports at build.
- "Workflows replace agents." Agents remain the LLM unit; workflows orchestrate agents and functions when control flow must be explicit.
- "If I used Kernel plugins I must rewrite everything." Python migration docs support converting many
KernelFunctionassets with compatibility helpers while you re-home agents. - "Multi-agent chat is the only pattern." Sequential chat is one pattern; concurrent, Magentic, and typed graphs are first-class too.
FAQs
What is Microsoft Agent Framework 1.0 in one sentence?
An open-source multi-language SDK that unifies AutoGen-style multi-agent orchestration with Semantic Kernel-style enterprise features and adds graph-based workflows for production agent systems.
When did 1.0 ship?
Microsoft announced Agent Framework version 1.0 in early April 2026 for Python and .NET after an October 2025 introduction and a February 2026 release candidate. Confirm exact package versions on PyPI/NuGet at build.
Is AutoGen still the right package for new work?
For new production work, prefer Microsoft Agent Framework. Treat AutoGen as legacy/maintenance relative to the successor unless you have a deliberate research reason to stay.
What happens to Semantic Kernel skills and plugins?
The conceptual model becomes tools and middleware on agents and workflows. Migration guides map kernel functions, DI, and invocation patterns to Agent Framework APIs.
Does Agent Framework support both Python and .NET?
Yes. Python installs via pip install agent-framework; .NET uses Microsoft.Agents.AI packages. A Go SDK also exists with a different maturity profile - verify before betting production on it.
How do sessions differ from AutoGen threads?
Agents are largely stateless per run unless you pass an AgentSession (or provider-backed session). Create or resume sessions explicitly so conversation history is intentional.
What replaces AutoGen RoundRobinGroupChat?
Orchestration builders such as sequential multi-agent workflows approximate turn-taking collaboration. Magentic builders cover manager-led multi-agent work. Exact class names can shift - verify samples at build.
What replaces Semantic Kernel filters?
Middleware at agent, function, and chat layers for logging, policy, blocking, and result transformation without rewriting tool bodies.
Do I need Azure to use Agent Framework?
No. OpenAI and other providers are supported through chat clients. Azure Foundry integration is a major strength for enterprise hosting, not a hard requirement for every sample.
Are graph workflows required for two agents?
No. Start with two agents and a sequential orchestration or a simple handoff. Graduate to WorkflowBuilder when you need typed edges, fan-out/join, checkpoints, or HITL gates.
Where is official migration documentation?
Microsoft Learn hosts migration guides from AutoGen and from Semantic Kernel under the Agent Framework documentation set. Use those as the source of truth over blog summaries.
How does this compare to LangGraph or CrewAI?
Agent Framework is Microsoft's unified stack with strong Azure/enterprise hooks. LangGraph emphasizes general state graphs; CrewAI emphasizes role/task crews. Compare control flow and ops needs rather than logos alone.
Related
- Microsoft Agent Framework Basics - first two-agent handoff
- Conversational Multi-Agent Patterns: Agent-to-Agent Chat - turn-based collaboration recipe
- Graph-Based Workflows in Microsoft Agent Framework - typed graph orchestration
- Enterprise Plugins and Connectors from Semantic Kernel - tools and connectors path
- Migrating an Existing AutoGen Project to Microsoft Agent Framework - practical migration walkthrough
- Governance and Enterprise Controls in Microsoft Agent Framework - middleware and policy
- Microsoft Agent Framework Best Practices - production checklist
- What Actually Differs Between Agent Frameworks - framework comparison axes
Stack versions: Pins from the category manifest (verify at build): OpenRouter (~315+ models, July 2026 pricing/fees); LangGraph 1.0+; CrewAI 1.14+; Microsoft Agent Framework 1.0; Vercel AI SDK 6; Pydantic AI (latest); LlamaIndex (latest); OpenAI Agents SDK (latest + MCP); MCP (Linux Foundation governance); A2A (HTTP+SSE+JSON-RPC 2.0); Solana
@solana/web3.js+@solana/spl-token.