Semantic Kernel vs Agent Framework is a successor choice, not a two vendor bake off. Microsoft Agent Framework is the production ready path for new Microsoft stack agents: it reached version 1.0 for .NET and Python in April 2026, folds in AutoGen style multi agent patterns, and drops the Kernel as the center of the API. Semantic Kernel remains supported as a 1.x line for critical bugs and security fixes, but most new features go to Agent Framework. Stay on Semantic Kernel if a working app needs no missing feature and you can plan the move. Start on Agent Framework (or migrate now) if you are greenfield on Azure or .NET, or you need workflows with checkpointing and the newer orchestration patterns.

We checked Microsoft's posts on Semantic Kernel and Microsoft Agent Framework and Agent Framework version 1.0, the Semantic Kernel migration guide, the Semantic Kernel and Agent Framework repositories, and PyPI on November 6, 2026, then rechecked PyPI and the 1.25.0 release notes on November 8 and PyPI again on November 20. We also ran a small Agent Framework agent on this box with a fake chat client and no paid key. For Semantic Kernel versus LangChain as a library pick, use our separate Semantic Kernel vs LangChain guide.

What's new (November 20, 2026): The latest Python agent-framework on PyPI is 1.26.0, released November 12, and it still needs Python 3.11 or later. When we rechecked on November 20, the github.com/microsoft/agent-framework repository returned a 404 error, so its release notes were not reachable; the PyPI package and the Microsoft Learn docs were still online. The 1.25.0 release (November 7) was the breaking one: Python 3.11 minimum, MCP tool and prompt discovery capped at 100 pages and 1,000 items per catalog, and a 30 second default timeout on framework owned MCP requests. Our box test below used 1.24.0.

Semantic Kernel vs Agent Framework at a glance

ItemSemantic KernelMicrosoft Agent Framework
Role todayMaintained 1.x SDKSuccessor SDK (GA 1.0, April 2026)
Made byMicrosoftSame team as SK and AutoGen
LanguagesC#, Python, Java.NET and Python (Go in public preview)
Latest we sawPython semantic-kernel 1.47.0 (Nov 5, 2026)Python agent-framework 1.26.0 (Nov 12, 2026; needs Python 3.11+)
LicenseMITMIT
Core ideaA Kernel holds services, plugins and filtersAn agent wraps a chat client; tools are plain functions
Conversation stateCaller builds an AgentThread subclassAgent creates an AgentSession
Tools@kernel_function plugins on a kernelFunctions (or @tool) passed into the agent
WorkflowsProcess Framework in SKGraph workflows with checkpointing and pause or resume
Multi agentLimited relative to AutoGen era patternsSequential, concurrent, handoff, group chat, Magentic-One
Azure connectorsFirst party Azure OpenAI and relatedFoundry, Azure OpenAI, OpenAI, Anthropic, Bedrock, Gemini, Ollama and more
Best fitExisting SK apps that still workNew Microsoft stack agents; SK migrations

There is no drydock tool page for Agent Framework yet, so the table links Semantic Kernel and AutoGen from the catalog and cites Microsoft's docs for Agent Framework itself.

What each product is

Semantic Kernel is Microsoft's earlier SDK for prompts, plugins and agents. You create a Kernel, register chat services and plugin methods marked with @kernel_function (or [KernelFunction] in C#), and run agents such as ChatCompletionAgent. Filters wrap function calls for logging or policy. That design feels familiar if you already use .NET dependency injection. The top of the Semantic Kernel README and PyPI page now state that Semantic Kernel is Microsoft Agent Framework for new work, and they point readers at the migration guide.

Microsoft Agent Framework is the open source SDK that unifies Semantic Kernel's enterprise oriented pieces with AutoGen's orchestration research. The 1.0 announcement (April 3, 2026) lists stable single agents, middleware, memory providers, graph workflows with checkpointing, multi agent patterns from AutoGen, YAML declarations, MCP tool discovery, and migration assistants for Semantic Kernel and AutoGen. Install Python with pip install agent-framework (meta package over agent-framework-core and common providers) or dotnet add package Microsoft.Agents.AI for .NET.

If you need a durable graph outside Microsoft's stack, compare Agent Framework workflows with LangGraph in our LangGraph vs CrewAI vs OpenAI Agents SDK guide. TypeScript product teams often look at VoltAgent instead. Config first packaging as a Docker CLI plugin is a different job; see Docker Agent.

Support status and timeline

Microsoft's October 2025 FAQ says to treat Agent Framework as Semantic Kernel v2.0, built by the same team. Semantic Kernel 1.x keeps critical bug and security fixes for at least one year after Agent Framework became generally available. With 1.0 shipping in April 2026, that window runs to at least April 2027. Semantic Kernel still ships releases (Python 1.47.0 on November 5, 2026), so it is maintained, not abandoned. New features land primarily on Agent Framework.

AutoGen's repository is archived. Microsoft advises against new production use and points those patterns at Agent Framework. So the old three way choice (Semantic Kernel, AutoGen, everyone else) collapsed into: stay on SK while it still fits, migrate to Agent Framework inside Microsoft's lane, or pick a non Microsoft framework such as LangGraph.

What changed when the Kernel went away

The migration guide centers on one design shift: the Kernel is gone as the object every agent depends on.

Agents. In Semantic Kernel you built a kernel, added a chat service, then constructed a service specific agent (ChatCompletionAgent, OpenAIAssistantAgent, AzureAIAgent and similar). In Agent Framework you pass a chat client into Agent(...) in Python, or call chatClient.AsAIAgent(...) in .NET. One agent type covers the common chat client providers.

Tools. Semantic Kernel tools are plugin methods with @kernel_function, registered on a kernel or passed as plugins. Agent Framework takes ordinary Python functions (optionally decorated with @tool) or .NET methods via AIFunctionFactory.Create, passed in the tools list at agent creation. There is no plugin container you must keep alive. Existing KernelFunction objects can convert with .as_agent_framework_tool when you are on Semantic Kernel 1.38 or newer, which helps a gradual move.

Sessions. Semantic Kernel made the caller pick and construct an AgentThread subclass. Agent Framework asks the agent for a session (create_session / CreateSessionAsync) and you pass that session into each run. Hosted history deletion is provider specific; the session type does not always expose delete.

Invocation. invoke / InvokeAsync becomes run / RunAsync. Non streaming returns one AgentResponse with .text and a .messages list that can include tool calls and results. Streaming uses run(..., stream=True) or RunStreamingAsync.

Workflows and multi agent. Structured business processes and AutoGen style group chat, handoff and Magentic-One now live in Agent Framework's workflow and orchestration APIs, with checkpointing and human approval hooks that Semantic Kernel alone does not match.

Dependency injection. Register an AIAgent (or the Python agent) directly. You no longer register a Kernel just so agents can resolve it.

How to migrate from Semantic Kernel

Microsoft's guide and the samples under python/samples/semantic-kernel-migration in the Agent Framework repo suggest a practical order:

  1. Inventory plugins and agents. List every @kernel_function and every agent type you construct. Tools usually map one to one; agents may collapse several SK classes into one AF agent.
  2. Port tools first. Rewrite plugin methods as plain functions, or call .as_agent_framework_tool on existing KernelFunction instances while you cut over. Keep names and descriptions stable so prompts stay valid.
  3. Replace kernel construction with a chat client. Create OpenAIChatClient, FoundryChatClient or another provider client, then Agent(client=..., tools=..., instructions=...) (or .as_agent(...)).
  4. Swap threads for sessions. Replace manual ChatHistoryAgentThread (and cousins) with session = agent.create_session() and pass session= on each run.
  5. Update invoke loops. Read response.text instead of iterating many agent response items for the final answer. Tool traffic lives in response.messages.
  6. Move workflows last. If you used Process Framework or home grown multi agent loops, redesign them on Agent Framework workflows or orchestrations so you gain checkpoints and pause or resume.
  7. Use the migration assistants. The 1.0 post describes assistants that read Semantic Kernel (and AutoGen) code and propose a step by step plan. Treat their output as a checklist, not a blind patch.

Ship one service or one agent at a time. Shared tools behind MCP can keep a Semantic Kernel process and an Agent Framework process talking to the same integrations while you cut over. See what MCP is for that pattern.

What we verified on the box

In a clean Python 3.13 venv we installed agent-framework 1.24.0. A small chat client subclassed FunctionInvocationLayer and BaseChatClient so the agent could run tools without a paid model. On the first model turn the fake client returned a function_call for order_status with order_id A17. The framework invoked our @tool function, then the fake client returned the final text. agent.create_session() produced an AgentSession, and agent.run(...) returned Order A17 shipped Nov 5.

from agent_framework import Agent, tool

@tool
def order_status(order_id: str) -> str:
    """Get shipping status for an order."""
    return f"Order {order_id} shipped Nov 5"

# client: any chat client that supports function invocation
agent = Agent(client=client, name="support", instructions="help", tools=[order_status])
session = agent.create_session()
response = await agent.run("Status of order A17?", session=session)
print(response.text)

In a second venv we installed semantic-kernel 1.47.0 and imported ChatCompletionAgent and kernel_function successfully. We did not re run a full Semantic Kernel agent here; that path was already exercised with 1.46.0 in the LangChain comparison. Neither test used Azure, OpenAI or any paid API.

When to stay, migrate or start fresh

Stay on Semantic Kernel for now when production is stable, you need no Agent Framework only feature, and you can schedule migration before the support window's practical end. Java only teams still have a Semantic Kernel Java line; Agent Framework's GA languages are .NET and Python.

Migrate now when you need graph workflows with checkpointing, AutoGen style multi agent patterns, YAML declared agents, or you are about to build a large new SK feature that will be harder to port later. Prefer a tool first, agent by agent cutover over a big bang rewrite.

Start fresh on Agent Framework for new Azure or .NET agent services, and for greenfield Python work that must stay inside Microsoft's stack. If you are not tied to Microsoft, also weigh LangGraph, CrewAI and others in best AI agent framework for Python. CrewAI remains a fast role based prototype option; it is not a Semantic Kernel replacement inside Azure.

Semantic Kernel vs MCP. Neither replaces the other. Semantic Kernel and Agent Framework can both call MCP servers. MCP is a tool and context protocol; the frameworks are how you build the agent loop. Prefer MCP when you want the same tools shared across frameworks during a migration.

FAQ

Is Semantic Kernel free?

Yes. Semantic Kernel is open source under the MIT license. Agent Framework is also MIT. You pay for the models and cloud services you call (Azure OpenAI, Foundry, and others), not for the SDKs themselves.

How do I use Semantic Kernel today?

Install with pip install semantic-kernel or the .NET packages, create a Kernel, add a chat service, register plugins with @kernel_function, and run a ChatCompletionAgent. For new projects Microsoft recommends Agent Framework instead. Keep Semantic Kernel when you are maintaining an existing app and follow the migration guide when you are ready to move.

Is Semantic Kernel vs agent the same as vs Agent Framework?

People type both. In Microsoft's naming, "Agent Framework" means Microsoft Agent Framework, the successor SDK. An "agent" in Semantic Kernel was already a class such as ChatCompletionAgent. This guide compares the two SDKs. For SK versus LangChain, use Semantic Kernel vs LangChain.

Should I pick Agent Framework or LangGraph?

Pick Agent Framework when you want Microsoft's first party Azure and Foundry connectors, AutoGen style orchestrations in one Microsoft SDK, and a supported migration from Semantic Kernel or AutoGen. Pick LangGraph when you want a model neutral durable graph used widely outside Microsoft's stack. They solve similar orchestration jobs with different ecosystems.

What about Semantic Kernel vs CrewAI?

CrewAI is a role and task oriented multi agent library, not a Microsoft successor. Use CrewAI for quick crew style prototypes. Use Agent Framework when you need Microsoft support, Azure connectors and the official SK migration path. See also the Python roundup linked above.

When did Agent Framework 1.0 ship?

Microsoft announced version 1.0 for .NET and Python on April 3, 2026. Preview began around October 2025. By November 20, 2026 the Python meta package on PyPI was at 1.26.0, released November 12, and since 1.25.0 it requires Python 3.11 or later.