In November 2025 I stood up at DevFest Strasbourg to give a talk called Semantic Kernel and OpenAI. I had given it twice already that year, in January and in February.
The title said Semantic Kernel. The demo did not. Two weeks before the talk I had rewritten the whole thing on Microsoft Agent Framework, which was in preview, and I had not changed the slide. I changed the code before I changed the title.
This article is about what happened to that code afterwards, and what it tells you if you have Semantic Kernel in production today.
Four agents and a fridge
The demo was a cooking competition. Four agents, each one a few lines of instructions.
Samy is creative and proposes oriental recipes. Marie is a perfectionist and proposes classic ones. They both answer the same brief at the same time, in parallel. Then Chef Philippe reviews what they wrote, and Philippe is the only agent with a tool:
public class FridgeTool
{
[Description("Vérifie si un ingrédient est disponible dans le frigo.")]
public string CheckIngredient([Description("Nom de l'ingrédient")] string ingredient)
{
var stock = new List<string> { "oeufs", "lait", "farine", "chocolat", "tomate", "pâtes" };
return stock.Contains(ingredient.ToLower()) ? "DISPONIBLE" : "RUPTURE DE STOCK";
}
}
Philippe checks the main ingredient against that list. If it is missing he refuses the recipe, in character, and the cook tries again. Five attempts maximum. Then the audience votes by pressing S or M, and a fourth agent, the Manager, promotes the winner and fires the loser with a line of its own invention.
It worked well on stage. Agents that argue are easier to follow than a chat completion that answers politely.
The part that did not work on stage
Before the first round, the program prints the fridge for the audience:
Frigo: Pâtes, Beurre, Ketchup, Pain, Fromage, Poulet
Read that list, then read the list in FridgeTool again. They share one ingredient.
The fridge the audience could see and the fridge Philippe could check were two different lists. So the cooks proposed chicken and cheese, which the screen said were available, and Philippe refused them for reasons nobody in the room could verify. He looked strict. He was reading a different fridge.
I only found this a year later, reading my own repository to write this article. On the day it made Philippe look good.
That is the first thing worth taking from this. The tool is the only part of an agent that can be wrong in a way the model cannot see. The model cannot check the fridge. It can only ask, and believe the answer.
Why there was no Kernel in any of it
Here is what made me rewrite the demo two weeks before the talk.
Semantic Kernel is built around the Kernel object. Every agent needs one. Plugins are registered on it. The agent reads its services from it. If you learned Semantic Kernel, you learned to build a Kernel first.
In Agent Framework there is no Kernel. An agent is created from a chat client, and a chat client is anything that implements IChatClient from Microsoft.Extensions.AI. Four agents became four lines.
Giving Philippe his tool became one line too:
var philippe = client.GetChatClient(modelId).CreateAIAgent(
instructions: "Tu es le Chef Philippe. Tu es EXIGEANT. [...] " +
"1. Vérifie l'ingrédient principal avec l'outil CheckIngredient. " +
"2. Si MANQUANT -> Refuse violemment.",
tools: [AIFunctionFactory.Create(new FridgeTool().CheckIngredient)]
);
In Semantic Kernel that same tool needs four things: a [KernelFunction] attribute on the method, a plugin to wrap it, a Kernel to hold the plugin, and the Kernel passed to the agent. For a demo I had to rebuild on stage in twenty minutes, that decided it.
A year later, I opened the file
I came back to this project to measure a migration before recommending one to you. I expected to find Semantic Kernel code and to time myself moving it.
There was nothing to migrate. I had already left.
What I found instead was my own code aging. The project pins Microsoft.Agents.AI.OpenAI version 1.0.0-preview.251114.1, a preview build from 14 November 2025. Stable 1.0.0 came out on 2 April 2026, and the names moved on the way there.
| My demo, November 2025 | The documentation today | In my file |
|---|---|---|
GetChatClient(model).CreateAIAgent(...) |
chatClient.AsAIAgent(...) |
4 times |
AgentRunResponse |
AgentResponse |
2 times |
response.Messages.LastOrDefault()?.Text |
response.Text |
6 times |
AIFunctionFactory.Create(...) |
unchanged | 1 time |
Look at the last row.
Tool registration is the part I spent the most time on in the talk, because it is the part people ask about. It is the only line in the table that still matches the documentation a year later. Everything I treated as setup code moved, and the thing I treated as the subject stayed.
Two of the chapters in every migration guide do not apply to this project at all. There is no Kernel in it, because there never was one. And there is no session either: every call is RunAsync(prompt) with no session argument, so the thread change cannot touch it.
So the honest size of my own migration is three renames across twelve call sites. One afternoon. The migration that cost me something was not Semantic Kernel to Agent Framework. It was preview to stable, inside the same library, and nobody sends you a notice when your conference demo expires.
Now the part you came for
If you have Semantic Kernel in production, your migration is bigger than mine, and these are the changes you will meet.
| Semantic Kernel | Agent Framework | |
|---|---|---|
| Namespace | Microsoft.SemanticKernel |
Microsoft.Agents.AI |
| Base type | Agent |
AIAgent |
| Creating one | build a Kernel, then new ChatCompletionAgent { Kernel = kernel } |
chatClient.AsAIAgent(instructions) |
| Agent types | one class per service | one ChatClientAgent for all of them |
| Threads | new OpenAIAssistantAgentThread(client) |
await agent.CreateSessionAsync() |
| Tools | attribute, plugin, kernel, pass the kernel | tools: [AIFunctionFactory.Create(f)] |
| Calling it | InvokeAsync, returns IAsyncEnumerable |
RunAsync, returns one AgentResponse |
Three of those rows deserve a warning.
AgentSession has no delete method. Semantic Kernel threads had thread.DeleteAsync(). If your provider hosts the chat history and you need to delete it, you now keep track of your sessions and delete through the provider’s own SDK, using session.ConversationId. The migration guide explains why: not every provider supports hosted history, so the API no longer pretends they all do. If you have a data retention requirement, this is the line in your code that needs attention, not the agent creation.
RunAsync returns one object, not a stream. Semantic Kernel returned IAsyncEnumerable even for a non-streaming call. Agent Framework gives you one AgentResponse: the text in AgentResponse.Text, and every message of the turn, tool calls and their results included, in AgentResponse.Messages. My demo reads Messages.LastOrDefault()?.Text six times because Text did not exist yet in the preview I used.
Tools lose their attributes. A plain method works. [Description] on it is optional instead of required, which is why the attribute survived in my FridgeTool without being needed.
Should you migrate now?
Three cases, and only one is urgent.
Starting something new. Use Agent Framework. There is no reason to start on the predecessor.
Semantic Kernel in production, working. Nothing is broken and no deadline has been published. Migrate when you next open that code for another reason, not as a project of its own. The one thing I would do this month is read your own code for hosted thread deletion.
Blocked on something only Agent Framework has. This is the real reason to move and the only one that justifies its own sprint. Graph-based workflows for multi-agent orchestration are the main example.
If you are on Python there is a fourth option. Semantic Kernel 1.38 and later can turn a KernelFunction into an Agent Framework tool with as_agent_framework_tool, so your existing functions run inside a new agent while you move the rest.
What Microsoft has said, and what it has not
The Semantic Kernel repository now opens with a banner saying Semantic Kernel is now Microsoft Agent Framework, and calling Agent Framework its successor. The documentation says the same thing in more detail: Agent Framework is the direct successor to both Semantic Kernel and AutoGen, built by the same teams.
What it has not said is when Semantic Kernel stops being supported. I could not find a date. The repository README does not give one, still describes Semantic Kernel as a current SDK, and still invites feature proposals. Several blog posts state one year after Agent Framework reached general availability, which would put the end around 2 April 2027, but I could not find that commitment on a Microsoft page. If you need a date for a migration plan, ask Microsoft rather than quoting a blog. Including this one.
You can plan without the date anyway. The version history of Microsoft.Agents.AI carries a publication date for every release: first release candidate on 20 February 2026, stable 1.0.0 on 2 April 2026, and version 1.28.0 by 6 November 2026. Twenty-eight minor versions in seven months, about one every ten days. That release pace answers the question on its own.
Next
The next article takes one working Semantic Kernel agent with a plugin and moves it, call by call, with the compiler errors in the order they arrive.
And I am going to fix Philippe’s fridge. The demo is on GitHub if you want to read the broken version first.
Sources
Documentation:
- Semantic Kernel to Agent Framework migration guide
- Microsoft Agent Framework overview
- Semantic Kernel documentation
Repositories and packages:
- microsoft/agent-framework
- microsoft/semantic-kernel
- Migration samples for .NET
Microsoft.Agents.AIon NuGet, where the version history gives the dates above
Every API detail above comes from the migration guide and the overview page rather than from secondary guides, because the names changed more than once across the five release candidates and older posts still show the earlier ones.