Von Semantic Kernel zum Microsoft Agent Framework - Was sich wirklich geändert hat

Tim Steiner

20 März 2026 — 6 Min. Lesezeit

Einleitung

Im Februar 2026 hat Microsoft das Microsoft Agent Framework offiziell als Release Candidate veröffentlicht - den Nachfolger von Semantic Kernel und AutoGen. Was als „AI Orchestration SDK" begann, ist jetzt ein vollwertiges Framework für Agents, Multi-Agent-Workflows und Enterprise-Szenarien.

Für mich war Semantic Kernel seit den frühen Tagen ein fester Bestandteil meines AI-Toolkits. Jetzt, wo das neue Agent Framework als RC vorliegt, ist es Zeit für einen ehrlichen Blick: Was hat sich geändert? Was bleibt? Und wie migrierst du deine bestehenden Projekte?

Was du in diesem Blogpost findest:

Semantic Kernel bis Ende 2024: Der Stand der Dinge
Die Fusion mit AutoGen - warum und wie
Microsoft Agent Framework: Die vier Bausteine
Vom alten SK-Agent zum neuen Framework
Code-Beispiele: Alter vs. neuer Ansatz
Migration: Was du wissen musst
Fazit und Einordnung

Semantic Kernel bis Ende 2024

Semantic Kernel (SK) startete als Open-Source-SDK, um LLM-Aufrufe in bestehende Anwendungen zu integrieren. Die Kernidee: Plugins, Planner und Memory als Bausteine für AI-gestützte Workflows.

Ende 2024 sah SK ungefähr so aus:

Kernel: Zentrales Objekt für Plugin-Management und LLM-Integration
Plugins: Funktionen, die der Kernel aufrufen kann (nativ oder via Prompt)
Planner: Automatische Orchestrierung von Plugin-Aufrufen
Memory: Semantische Suche über eingebettete Dokumente
Agents: Ein experimentelles Feature für agentenbasierte Workflows

Die Agent-Fähigkeiten waren zu dem Zeitpunkt rudimentär - ein ChatCompletionAgent und ein OpenAIAssistantAgent. Für ernsthafte Multi-Agent-Szenarien hat man oft auf AutoGen zurückgegriffen.

// Semantic Kernel "Classic" - Ende 2024
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;

var kernel = Kernel.CreateBuilder()
    .AddAzureOpenAIChatCompletion(
        deploymentName: "gpt-4o",
        endpoint: "<endpoint>",
        apiKey: "<key>")
    .Build();

// Plugin registrieren
kernel.Plugins.AddFromType<ProductionPlugin>();

// Einfacher Agent
var agent = new ChatCompletionAgent
{
    Name = "ProductionAssistant",
    Instructions = "Du hilfst bei der Produktionsplanung.",
    Kernel = kernel
};

Das funktionierte, war aber für Multi-Agent-Szenarien schnell an den Grenzen. Wenn du zwei Agents koordinieren wolltest, hast du entweder auf das experimentelle AgentGroupChat gesetzt oder dir eigene Orchestrierung gebaut.

Die Fusion mit AutoGen

AutoGen war Microsofts anderer Ansatz für AI Agents - entwickelt von Microsoft Research. Während SK den „SDK für Entwickler"-Ansatz verfolgte, war AutoGen ein Research-Framework für Multi-Agent Conversations.

Das Problem: Zwei Microsoft-Projekte mit überlappenden Zielen, unterschiedlichen APIs und verschiedenen Communities. Anfang 2025 fiel die Entscheidung, beide unter einem Dach zu vereinen.

Die Logik dahinter:

Aspekt	Semantic Kernel	AutoGen	Zusammen
Stärke	Enterprise SDK, Plugin System	Multi-Agent, Research	Vollständiges Agent Framework
Schwäche	Begrenzte Agent-Patterns	Kein Enterprise-Focus	Behoben
Community	.NET + Python Devs	Research, Python	Vereinte Community
Orchestrierung	Einfacher Planner	GroupChat, Handoff	Graph-basierte Workflows

💡 Hinweis: Die Fusion war keine feindliche Übernahme. AutoGen lebt als eigenständiges Open-Source-Projekt weiter, aber die Enterprise-Features und der Agent Runtime fließen in das Microsoft Agent Framework ein. Die konsolidierte Vision: ein Open-Source-Framework für .NET und Python.

Microsoft Agent Framework - Die vier Bausteine

Am 20. Februar 2026 wurde das Microsoft Agent Framework offiziell als Release Candidate angekündigt. Der alte Semantic Kernel Blog unter devblogs.microsoft.com/semantic-kernel/ wurde in „Microsoft Agent Framework" umbenannt - ein klares Signal, dass dies kein Nebenprojekt ist.

Das Framework wird offiziell als Nachfolger von Semantic Kernel und AutoGen positioniert und besteht aus vier Bausteinen:

1. Agent Framework Core

Das Herzstück: Einfache Agent-Erstellung, Function Tools mit typsicheren Definitionen, Multi-Provider-Support (Microsoft Foundry, Azure OpenAI, OpenAI, GitHub Copilot, Anthropic Claude, Ollama und mehr). Die neue API lebt im NuGet-Paket Microsoft.Agents.AI:

// Microsoft Agent Framework - Einfacher Agent
// NuGet: Microsoft.Agents.AI (1.0.0-rc4)
using Microsoft.Agents.AI;
using OpenAI;
using Azure.Identity;
using System.ClientModel.Primitives;

var agent = new OpenAIClient(
    new BearerTokenPolicy(
        new AzureCliCredential(),
        "https://ai.azure.com/.default"),
    new OpenAIClientOptions
    {
        Endpoint = new Uri(
            "https://<resource>.openai.azure.com/openai/v1")
    })
    .GetResponsesClient("gpt-4.1")
    .AsAIAgent(
        name: "ProductionAssistant",
        instructions: "Du hilfst bei der Produktionsplanung.");

Console.WriteLine(
    await agent.RunAsync("Wie optimiere ich die OEE meiner Linie?"));

Vergleich das mit dem SK-Classic-Pattern oben - weniger Boilerplate, kein Kernel-Objekt nötig für einfache Szenarien.

2. Orchestrations (Workflows)

Hier fließen die AutoGen-Konzepte ein: Graph-basierte Workflows mit Sequential, Concurrent, Handoff und Group Chat Patterns. Alles mit Streaming, Checkpointing und Human-in-the-Loop-Unterstützung.

// Multi-Agent Workflow - Sequential Pattern
// NuGet: Microsoft.Agents.AI.Workflows
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;
using OpenAI;
using Azure.Identity;
using System.ClientModel.Primitives;

var chatClient = new OpenAIClient(
    new BearerTokenPolicy(
        new AzureCliCredential(),
        "https://ai.azure.com/.default"),
    new OpenAIClientOptions
    {
        Endpoint = new Uri(
            "https://<resource>.openai.azure.com/openai/v1")
    })
    .GetChatClient("gpt-4.1")
    .AsIChatClient();

ChatClientAgent analyst = new(chatClient,
    "Analysiere OEE-Daten und identifiziere den größten Verlustfaktor.",
    "Analyst");

ChatClientAgent planner = new(chatClient,
    "Erstelle einen konkreten Aktionsplan basierend auf der Analyse.",
    "Planner");

// Sequential Workflow: Analyst → Planner
Workflow workflow = AgentWorkflowBuilder
    .BuildSequential(analyst, planner);

List<ChatMessage> messages = [
    new(ChatRole.User,
        "OEE ist diese Woche auf 68% gefallen. Was tun?")
];

await using StreamingRun run =
    await InProcessExecution.RunStreamingAsync(workflow, messages);

await run.TrySendMessageAsync(new TurnToken(emitEvents: true));
await foreach (WorkflowEvent evt in run.WatchStreamAsync())
{
    if (evt is AgentResponseUpdateEvent e)
    {
        Console.Write(e.Update.Text);
    }
}

3. Agent Skills

Agent Skills sind portable, wiederverwendbare Skill-Pakete, die Agents on-demand laden können. Ein Skill ist im Kern ein Markdown-Dokument, das beschreibt, was der Skill kann, und Step-by-Step-Anleitungen liefert. Agents entdecken und laden Skills zur Laufzeit - du musst dafür keine Zeile an deinem Agent-Code ändern.

💡 Praxis-Tipp: Agent Skills eignen sich perfekt, um Domain-Expertise wiederverwendbar zu verpacken. Ein „OEE-Analyse"-Skill, ein „Predictive Maintenance"-Skill - jedes Team erstellt seine Skills, und Agents konsumieren sie nach Bedarf.

4. Agent Harness

Agent Harness verbindet das Model Reasoning mit der realen Ausführung: Shell- und Filesystem-Zugriff, Approval-Flows und Context-Management über lange Sessions. Damit können Agents nicht nur Text generieren, sondern auch Befehle ausführen, Dateien inspizieren und mit der Umgebung interagieren - alles mit kontrollierbaren Genehmigungsmechanismen.

// Agent Harness - Shell-Ausführung mit Approval
// Vereinfachtes Beispiel aus dem offiziellen Blogpost
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;
using OpenAI;
using System.ComponentModel;
using System.Diagnostics;

[Description("Führt einen Shell-Befehl aus und gibt stdout/stderr zurück.")]
static string RunBash(
    [Description("Der auszuführende Befehl.")] string command)
{
    using Process process = new()
    {
        StartInfo = new ProcessStartInfo
        {
            FileName = "/bin/bash",
            ArgumentList = { "-lc", command },
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false,
        }
    };
    process.Start();
    process.WaitForExit(30_000);
    var stdout = process.StandardOutput.ReadToEnd();
    var stderr = process.StandardError.ReadToEnd();
    return $"stdout:\n{stdout}\nstderr:\n{stderr}\nexit_code:{process.ExitCode}";
}

⚠️ Wichtig: Shell-Ausführung sollte immer in einer isolierten Umgebung laufen, und Approval-Flows sollten aktiv bleiben. Agent Harness gibt dir die Kontrolle - aber du musst sie auch nutzen.

Das alte SK Plugin-System lebt weiter

Falls du dich fragst: Das klassische Semantic Kernel existiert weiterhin als NuGet-Paket (Microsoft.SemanticKernel, aktuell Version 1.74.0). Die Kernel/Plugin/Memory-Architektur bleibt erhalten und ist weiterhin der richtige Ansatz, wenn du AI in bestehende Anwendungen integrierst.

Das neue Agent Framework baut darauf auf, bietet aber zusätzlich:

Konsistente Agent-Abstraktion über verschiedene Providers hinweg
Graph-basierte Workflows statt manueller Orchestrierung
Interoperabilität mit A2A (Agent-to-Agent), AG-UI und MCP (Model Context Protocol)
Multi-Provider: Azure OpenAI, OpenAI, GitHub Copilot, Anthropic Claude, Ollama - alles über die gleiche API

Das Plugin-Konzept von SK - native Methoden mit [KernelFunction]-Attribut - bleibt dabei ein valider Baustein. Ein Beispiel aus dem IoT-Kontext:

// Plugin - funktioniert mit SK und Agent Framework
using Microsoft.SemanticKernel;
using System.ComponentModel;

public class OEEPlugin
{
    [KernelFunction, Description("Berechnet die OEE aus den drei Faktoren")]
    public string CalculateOee(
        double availability,
        double performance,
        double quality)
    {
        var oee = availability * performance * quality;
        return $"OEE: {oee:P1} (Verfügbarkeit: {availability:P1}, " +
               $"Leistung: {performance:P1}, Qualität: {quality:P1})";
    }

    [KernelFunction, Description("Identifiziert den größten Verlustfaktor")]
    public string IdentifyLoss(
        double availability,
        double performance,
        double quality)
    {
        var factors = new Dictionary<string, double>
        {
            ["Verfügbarkeit"] = availability,
            ["Leistung"] = performance,
            ["Qualität"] = quality
        };
        var worst = factors.MinBy(f => f.Value);
        return $"Größter Verlustfaktor: {worst.Key} mit {worst.Value:P1}";
    }
}

📌 Tipp: Plugins lassen sich zwischen Projekten und Teams teilen. Erstelle eine Bibliothek von Plugins für deine Organisation - das spart Zeit und sorgt für konsistente Funktionalität.

Migration: Von SK zu Microsoft Agent Framework

Microsoft hat offizielle Migration Guides veröffentlicht - sowohl für Semantic Kernel als auch für AutoGen.

Die wichtigsten Änderungen auf einen Blick:

Was gleich bleibt:

Grundlegendes Plugin-Konzept mit [KernelFunction]-Attribut
Azure OpenAI und OpenAI als Provider
Python und .NET als Zielsprachen

Was sich ändert:

Neues NuGet-Paket: Microsoft.Agents.AI statt Microsoft.SemanticKernel.Agents.Core
ChatClientAgent statt ChatCompletionAgent für einfache Agents
AgentWorkflowBuilder für Sequential, Concurrent und Handoff Patterns
Workflow + InProcessExecution statt manueller AgentGroupChat
Kein Kernel-Objekt mehr nötig für einfache Agent-Szenarien

// VORHER: Semantic Kernel Agent
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;

var kernel = Kernel.CreateBuilder()
    .AddAzureOpenAIChatCompletion("gpt-4o", "<endpoint>", "<key>")
    .Build();

var agent = new ChatCompletionAgent
{
    Name = "Assistant",
    Instructions = "Du hilfst bei Fragen.",
    Kernel = kernel
};

// NACHHER: Microsoft Agent Framework Agent
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;
using OpenAI;

IChatClient chatClient = new OpenAIClient("<api-key>")
    .GetChatClient("gpt-4.1")
    .AsIChatClient();

ChatClientAgent agent = new(chatClient,
    "Du hilfst bei Fragen.",
    "Assistant");

Der Kern der Migration: Das neue Framework setzt auf Microsoft.Extensions.AI als Abstraktion (IChatClient), statt an SK's Kernel-Objekt gebunden zu sein. Das macht Provider-Wechsel trivial.

Fazit

Die Evolution von Semantic Kernel zum Microsoft Agent Framework war absehbar - Microsoft hat erkannt, dass ein reines Orchestration-SDK nicht ausreicht. Es braucht ein Framework, das den gesamten Lebenszyklus von Agents abdeckt: von der Erstellung über Workflows bis zu Shell-Ausführung und Domain-Expertise.

Die Fusion mit AutoGen bringt Patterns, die wir vorher mühsam selbst implementieren mussten. Graph-basierte Workflows, Handoff-Strategien und Multi-Agent-Orchestrierung sind jetzt First-Class-Features statt experimenteller APIs.

Mein Rat: Wenn du noch auf dem alten Semantic Kernel mit ChatCompletionAgent und AgentGroupChat arbeitest, ist jetzt der richtige Zeitpunkt für die Migration. Das Agent Framework ist als Release Candidate stabil genug für neue Projekte, und die offiziellen Migration Guides machen den Umstieg überschaubar.

Für bestehende SK-Projekte, die primär Kernel + Plugins nutzen: Kein Stress. Microsoft.SemanticKernel wird weiterhin gepflegt (aktuell Version 1.74.0). Aber für alles, was mit Agents zu tun hat, führt kein Weg mehr am neuen Framework vorbei.