Stell dir vor, du hast ein intelligentes System, das eigenständig Probleme analysiert, Entscheidungen trifft und sich kontinuierlich verbessert – genau das ermöglichen KI-Agenten. Diese nächste Generation der Automatisierung geht weit über klassische Workflows hinaus und eröffnet völlig neue Möglichkeiten für IT-Operations, Supportsysteme und viele weitere Anwendungsbereiche. Im Gegensatz zu traditionellen Systemen mit festen Regeln passen sich moderne KI-Agenten dynamisch an, lernen aus Erfahrungen und treffen eigenständig Entscheidungen. Diese Systeme lösen komplexe Aufgaben und lernen aus Interaktionen.

In diesem Artikel werden wir uns zunächst mit den theoretischen Grundlagen von KI-Agenten und agentenbasierten Systemen befassen. Anschließend folgt eine praxisnahe Einführung in die Entwicklung eigener KI-Agenten mit dem Semantic Kernel. Ziel ist es, ein tiefgehendes Verständnis für die Konzepte zu vermitteln und gleichzeitig eine praktische Anleitung bereitzustellen, mit der Entwickler:innen eigene Projekte umsetzen können.

Zeitachse und Entwicklung

Frühe 2000er: Traditionelle Workflow-Engines

In den frühen 2000ern wurde die Automatisierung weitgehend von Workflow-Engines wie Nintex, Windows Workflow Foundation, IBM WebSphere Process Server und BizTalk Server dominiert. Diese Tools ermöglichten es Unternehmen erstmals, Geschäftsprozesse ohne tiefgehende Programmierung zu automatisieren. Bekannte Merkmale waren:

• Workflow-Engines zeichneten sich durch starre, vordefinierte Logiken und Entscheidungsbäume aus.
• Entwickler:innen implementierten Automatisierungen mithilfe von if-then-else Bedingungen und regelbasierten Konfigurationen.
• Der Fokus lag auf wiederholbaren, strukturierten Aufgaben mit klar definierten Ergebnissen.
• Systeme waren wenig anpassungsfähig und erforderten umfangreiche Neukonfigurationen bei Prozessänderungen.

Diese Tools steigerten zwar die Effizienz in strukturierten Umgebungen, waren jedoch begrenzt in der Verarbeitung unstrukturierter Daten und der Anpassung an dynamische Geschäftsanforderungen.

Mitte der 2010er: Aufstieg von KI und maschinellem Lernen

Während regelbasierte Systeme in den frühen 2000ern dominierten, begann in den 2010ern eine neue Ära mit datengetriebenen Ansätzen. Mit dem zusätzlichen Aufkommen von maschinellem Lernen verlagerte sich der Fokus zu mehr automatisierter Entscheidungsfindung. Dies führte zu flexibleren und intelligenteren Automatisierungslösungen, die auf Mustern und Vorhersagen basierten. Wichtige Entwicklungen waren:

• _Einführung von prädiktiven Analysen:_Systeme begannen, Datenmuster zu nutzen, um Vorhersagen zu treffen und manuelle Eingriffe zu reduzieren (SAS Advanced Analytics, IBM SPSS Modeler, RapidMiner).
• _Übergang von regelbasierten zu lernbasierten Modellen:_KI-Anwendungen analysierten historische Daten und passten sich verändernden Bedingungen an (TensorFlow (2015), Microsoft Azure Machine Learning (2015), H2O.ai).
• _Frühe Anwendungen:_Betrugserkennung, Empfehlungssysteme und Prozessoptimierung (PayPal Fraud Detection, Amazon Recommendation Engine, Google RankBrain (2015)).
• Diese Veränderungen legten die Grundlage für eine intelligentere Automatisierung, jedoch wurde KI noch weitgehend als Ergänzung zu regelbasierten Workflows und nicht als eigenständige Entscheidungsinstanz genutzt (UiPath, Automation Anywhere, Blue Prism).

Frühe 2020er: Aufkommen von Generativer KI

Ende der 2010er Jahre erlebte die Welt den Aufstieg von Generativer KI, wie z. B. GPT, das bemerkenswerte Fähigkeiten im Verstehen und Generieren natürlicher Sprache zeigte. Mit der Fähigkeit, menschenähnliche Texte zu generieren und kontextbezogene Antworten zu liefern, wurde KI nicht mehr nur als unterstützendes Werkzeug, sondern als eigenständige Entscheidungsinstanz betrachtet. Hauptmerkmale sind:

• KI-Systeme wurden kontextbewusster und konnten menschenähnliche Texte verstehen und generieren.
• Generative KI weckte das Interesse an intelligenter Automatisierung, die über traditionelle Workflows hinausging.
• Anwendungen dehnten sich auf Chatbots, virtuelle Assistenten und KI-gestützte Inhaltserstellung aus.

Mit diesen Fortschritten wurde der Grundstein für KI-Agenten gelegt – autonome Systeme, die nicht nur Entscheidungen treffen, sondern auch aus Interaktionen lernen und sich kontinuierlich verbessern.

Gegenwart: KI-Agenten und agentenbasierte Systeme

Mit den kontinuierlichen Fortschritten in der KI stehen wir nun an der Schwelle zu Agenten-basierter Technologie – autonomen Entitäten, die ihre Umgebung wahrnehmen, Entscheidungen treffen und handeln, um bestimmte Ziele zu erreichen.

Beschreibung von KI-Agenten

Im Gegensatz zu herkömmlichen Workflows sind KI-Agenten in der Lage, unstrukturierte Daten zu verarbeiten und komplexe Entscheidungen zu treffen. Diese Agenten lernen aus Interaktionen und können, wenn implementiert, ihre Leistung kontinuierlich verbessern. KI-Agenten sind zielorientiert und passen ihr Verhalten dynamisch an neue Gegebenheiten an. Zur Optimierung ihrer Entscheidungsfähigkeit nutzen sie fortschrittliche Techniken wie Reinforcement Learning, selbstüberwachtes Lernen und tiefe neuronale Netze.

Abb. 1: AI-Ops-Agenten: Eine Gruppe von KI-Agenten, die Probleme am lokalen System angehen

KI-Agenten stellen einen Paradigmenwechsel dar – von statischer Automatisierung hin zu adaptiven, sich selbst verbessernden Systemen, die in dynamischen, realen Umgebungen funktionieren können (Abb. 1).

Agentenbasierte Systeme (oft auch agentische Systeme genannt) führen den Ansatz von KI-Agenten fort. Unter diesem Begriff versteht man das Skalieren der Fähigkeiten von KI-Agenten. Während KI-Agenten oftmals als eine Gruppe von Agenten bezeichnet werden, die ein bestimmtes Thema verarbeiten, übernehmen agentenbasierte Systeme die Orchestrierung über mehrere Gruppen von KI-Agenten, wodurch eine hohe Skalierbarkeit erreicht wird (Abb. 2).

Ein Beispiel: Während eine Gruppe von KI-Agenten nur in der Lage ist, auf die Frage „Warum ist mein Netzwerk so langsam?” zu antworten, nutzt ein agentisches System die Fähigkeiten ganzer Gruppen von KI-Agenten (Netzwerk, Application Monitoring, TicketSysteme, usw.), um ein komplexeres Problem zu lösen.

Abb. 2: Skalierbares Agentic-System

Grundlegende KI-Technologien für KI-Agenten

KI-Agenten verwenden Schlüsseltechnologien der Künstlichen Intelligenz zur Analyse von Daten, zum Verstehen von Sprache und zur Verarbeitung visueller Informationen. Machine Learning, eine Unterkategorie der Künstlichen Intelligenz, ermöglicht es KI-Agenten, Datenmuster zu erkennen und Vorhersagen oder Entscheidungen zu treffen, basierend auf gesammelten Erfahrungen. Dies führt zu folgenden Spezialisierungen:

• Neuronale Netze und Deep Learning: Von Gehirnstrukturen inspirierte neuronale Netze helfen KI-Agenten, komplexe Daten zu verstehen. Deep Learning nutzt mehrschichtige Netze für Aufgaben wie Bild- und Spracherkennung.
• _Natürliche Sprachverarbeitung (NLP):_NLP ermöglicht die Verständigung in menschlicher Sprache – wichtig für Chatbots, virtuelle Assistenten und automatisierte Systeme.
• _Computer Vision:_KI-Agenten interpretieren visuelle Daten und treffen Entscheidungen, hilfreich in Robotik, Qualitätskontrolle und Gesichtserkennung.
• _Reinforcement Learning:_Durch Belohnungssysteme lernen KI-Agenten optimale Entscheidungen zu treffen, besonders in dynamischen Umgebungen.
• _Transformermodelle und LLMs:_Transformermodelle, eine Architektur für neuronale Netze, ermöglichen eine effiziente Verarbeitung und Generierung von Texten. Sie bilden die Grundlage für LLMs, die anhand großer Mengen an Textdaten trainiert werden und fortschrittliche Sprachverarbeitung, Textverständnis und Generierung ermöglichen.

Von der Theorie zur Praxis: Eigenen KI-Agent erstellen

In diesem Abschnitt entwickeln wir einen eigenen KI-Agenten mit Semantic Kernel. Wir gehen dabei schrittweise vor und beginnen mit dem Erstellen eines Projektes.

Warum Semantic Kernel?

Es gibt mehrere Frameworks zur Entwicklung von KI-Agenten, darunter LangChain/-Graph, AutoGen/2 und Semantic Kernel (Kasten: „Hinweise zu Semantic Kernel”). Wir verwenden Semantic Kernel, da es speziell für .NET optimiert ist und eine einfache Integration mit Large Language Models (LLMs) ermöglicht. Zudem wird es aktiv von der Community und Microsoft weiterentwickelt, was eine langfristige Unterstützung und Verbesserungen sichert.

Hinweise zu Semantic Kernel

• Preview Status: Semantic Kernel ist noch in der Preview-Phase, wird aber aktiv weiterentwickelt.
• unterstützte Sprachen: Neben C# unterstützt Semantic Kernel auch Python und Java, was Entwicklern Flexibilität bietet.
• Fokus auf Sprachmodelle: Semantic Kernel eignet sich besonders für KI-Agenten, die auf LLMs basieren.

In den nächsten Schritten werden wir:

1. Ein .NET-Projekt erstellen
2. Semantic Kernel installieren
3. Einen einfachen KI-Agenten bauen
4. Ein Agenten-Team aufsetzen

Die Voraussetzungen dafür sind:

• _Technische Kenntnisse:_Erfahrung mit C#, .NET und Terminal-Befehlen
• Zugang zu einem LLM: Azure OpenAI, OpenAI API oder lokal gehostete Modelle mit Ollama oder LMStudio

Kurze Einführung in den Semantic Kernel

Semantic Kernel ist ein Framework, das als Middleware zwischen Anwendungen und LLMs fungiert. Es bietet eine Abstraktionsschicht, die es Entwickler:innen ermöglicht, KI-Funktionen einfach in ihre Software zu integrieren. Durch den modularen Aufbau können verschiedene KI-Modelle und Plug-ins flexibel kombiniert werden.

Wichtige Merkmale sind:

• Einfache Integration: Lässt sich nahtlos in bestehende .NET-Projekte einbinden.
• Modularität: Flexible Anpassung von KI-Komponenten an spezifische Anforderungen.
• Skalierbarkeit: Unterstützt den Einsatz in großen Umgebungen und verteilten Systemen.

Durch den Einsatz von Semantic Kernel können Entwickler:innen leistungsfähige KI-Agenten erstellen und ihre Anwendungen mit intelligenten Funktionen erweitern.

Schritt-für-Schritt-Anleitung: Integration des Semantic Kernel mit dem Agent-Framework

Wir beginnen mit der Einrichtung eines neuen Projekts, fügen die notwendigen Abhängigkeiten hinzu und konfigurieren den Zugriff auf ein LLM. Am Ende dieses Abschnitts hast du eine funktionierende Basis für deinen KI-Agenten.

Ein nützliches Beispiel: „AI Ops”

Ich plane ein Analyse-System für AI Ops, das generative KI zur automatisierten Lösung von IT-Tickets nutzt. Das Ziel ist es, dass KI-Agenten Problembeschreibungen analysieren und lösen. Diese Agenten benötigen Zugriff auf Netzwerk, CPU und Speicher. Es wird einen Analyse-Agent und einen Bewertungs-Agent im Team geben. Das System soll eigenständig Probleme und Lösungen auf Expertenniveau finden können (Abb. 1).

Projekt erstellen und Semantic Kernel installieren

Der erste Schritt ist das Anlegen eines .NET-Projektes nach diesem Schema:

dotnet new console -o MyAIAgenten
cd MyAIAgenten

Für die Installation und Arbeit mit dem Semantic-Kernel-Framework benötigst du folgende NuGet-Pakete:

dotnet add package microsoft.SemanticKernel
dotnet add package microsoft.semantickernel.Agenten.abstractions --version 1.35.0-alpha
dotnet add package microsoft.semantickernel.Agenten.core --version 1.35.0-alpha
dotnet add package microsoft.semantickernel.Agenten.openai --version 1.35.0-alpha

Zugang zu einem LLM

Um einen KI-Agenten zu erstellen, benötigst du Zugriff auf ein LLM. Es gibt viele Möglichkeiten – beispielsweise eine der folgenden drei:

1. Azure OpenAI: Erstelle einen Azure OpenAI-Service im Azure-Portal und notiere den API-Schlüssel.
2. OpenAI API: Registriere dich auf der OpenAI-Webseite und generiere einen API-Schlüssel.
3. Lokale Modelle: Nutze Ollama oder LMStudio für ein lokal gehostetes Modell.

Falls du LMStudio verwendest, beachte, dass Function Calling derzeit nicht unterstützt wird. Ich empfehle daher Ollama als Model-Host für Semantic Kernel.

Ich nutze für dieses Projekt den Azure OpenAI-Service, weshalb ich die nachfolgenden Schritte entsprechend darauf abgestimmt habe. Die API von OpenAI bedarf nur geringfügige Änderungen im Code, da beide Vorgehensweisen in Semantic Kernel nahezu identisch implementiert sind.

Umgebungsvariablen setzen

Um Informationen wie API-Schlüssel als Konfiguration zu hinterlegen, speichere ich diese in Umgebungsvariablen. So lässt sich das Projekt auch leicht in anderen Umgebungen wie Docker verschieben.

Nun ist es an der Zeit eine Datei namens .env im Projektverzeichnis zu erstellen und folgende Zeilen hinzuzufügen:

AZURE_OPENAI_API_KEY=<dein_api_schluessel>
AZURE_OPENAI_ENDPOINT=<dein_api_endpunkt>
AZURE_OPENAI_MODEL_ID=<dein_deployment_model>

Das Deployment-Modell ist der Name des Modells, das du in Azure OpenAI bereitgestellt hast.

Installiere als Nächstes das DotNetEnv-Paket, um die Umgebungsvariablen in deinem Code zu laden: dotnet add package DotNetEnv. Falls noch nicht geschehen, erstelle eine .gitignore und füge .env hinzu, um nicht versehentlich sensiblen Inhalt in deinem Git Repo zu speichern.

Nachdem wir Semantic Kernel in unser .NET-Projekt integriert haben, erstellen wir nun einen einfachen KI-Agenten, der mit einem LLM interagiert. Mit diesem Wissen können wir nun beginnen den Code zu schreiben.

Semantic Kernel initialisieren

Um Semantic Kernel einzurichten und mit einem LLM zu verbinden, passen wir die Program.cs an wie in Listing 1.

Listing 1: Program.cs

class Program
{
static async Task Main(string[] args)
{
<em>//Alternative zu appsettings.json..:</em>
DotNetEnv.Env.Load(); <em>// lade die Env Vars</em>
<em>// Kernel initialisieren</em>
var builder = Kernel.CreateBuilder();
builder.AddAzureOpenAIChatCompletion(
Environment.GetEnvironmentVariable("AZURE_OPENAI_MODEL_ID"),
Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT"),
Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY"));
var kernel = builder.Build();

<em>// Klon anlegen, um eine Netzwerk-F&#xE4;higkeit bereitzustellen</em>
var networkKernel = kernel.Clone();
var pluginNetwork = KernelPluginFactory
.CreateFromType<NetworkMonitor>();
networkKernel.Plugins.Add(pluginNetwork);

<em>// zweiter Kernel mit Host-Monitoring-F&#xE4;higkeit</em>
var hostMetricsKernel = kernel.Clone();
var pluginHost = KernelPluginFactory
.CreateFromType<HostMetrics>();
hostMetricsKernel.Plugins.Add(pluginHost);
<em>//&#x2026; weiterer Code &#x2013; ein</em> <em>wenig logging und weiteres house keeping</em>
}
}

Zuerst wird der KernelBuilder erstellt. Mit AddAzureOpenAIChatCompletion bekommt der Kernel die Fähigkeit, mit entsprechendem LLM zu interagieren. Für diejenigen, die sich für eine Implementierung mit OpenAIs API entschieden haben, würde die Funktion dann builder.AddOpenAIChatCompletion heißen.

Wir klonen den Kernel, um spezialisierte Funktionen durch Plugins hinzuzufügen – zum Beispiel Netzwerkchecks oder Host-Metriken. Das Klonen ermöglicht eine Trennung der Verantwortlichkeiten. Es verhindert, dass Agenten falsche Funktionen aufrufen. Ein Agent kann nur die im Kernel vorhandenen Plug-ins verwenden, um seine vorgesehenen Aufgaben zu erfüllen.

In unserem Beispiel haben wir einen Agenten, der Netzwerkchecks durchführen kann.

KernelPluginFactory.CreateFromType<NetworkMonitor>();
networkKernel.Plugins.Add(pluginNetwork);

Um das Plug-in besser verstehen zu können, möchte ich nachfolgend einen Auszug aus der Plug-in-Klasse zeigen.

Listing 2: Klasse NetworkMonitor

[KernelFunction()]
[Description("Returns information about the network adapters")]
public static List<string> adapterInfos()
{
List<string> adapterInfos = new List<string>();
foreach (NetworkInterface ni in NetworkInterface.GetAllNetworkInterfaces())
{
string info = $"Name: {ni.Name}, Typ: {ni.NetworkInterfaceType}, Status: {ni.OperationalStatus}";
adapterInfos.Add(info);
}
return adapterInfos;
}

Mit Semantic Kernel können wir Methoden mit speziellen Decorators versehen. KernelFunction stellt die Verbindung zwischen Semantic Kernel und der Methode her. Description hilft dem LLM, die Methode inhaltlich zu verstehen (Listing 2). Dies ermöglicht es dem LLM, gezielt Funktionen aufzurufen, ohne direkten Zugriff auf das System zu haben. Parameter können ebenfalls übergeben werden und sollten unbedingt in der Description mit beschrieben sein.

Das Konzept ist simpel: Bei der Lösungssuche, etwa bei der Überprüfung von Netzwerkadaptern, generiert das LLM einen Function Call auf ‘ adapterInfos()’. Diese Funktionsaufrufe sind entscheidend für die Verbindung zwischen LLM und lokalen Ressourcen (eine tiefere Diskussion darüber würde jedoch den Rahmen sprengen).

Kurz gesagt, durch Decorators im Semantic Kernel erstellt das LLM ein JSON, füllt es mit Werten und gibt es an den Semantic Kernel zurück. Das LLM hat dabei keinen direkten Zugriff auf das System.

Unser erster Agent

Nun definieren wir einen ersten KI-Agenten, der als Netzwerkanalyst fungiert (Listing 3).

Listing 3

ChatCompletionAgent agentNetworkChecker = new()
{
Name = nameNetworkChecker,
Instructions =
"""
**Role:** You are a Network Checker with over 10 years of experience. You specialize in diagnosing network connectivity issues.

<em><&#x2026; (gek&#xFC;rzt) Der Prompt definiert die Rolle des Agenten und enth&#xE4;lt Anweisungen zur Analyse von Netzwerkproblemen></em>
""",
Kernel = networkKernel,
Arguments = new KernelArguments(new AzureOpenAIPromptExecutionSettings() { FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() }),
LoggerFactory = loggerFactory
};

Ein Agent benötigt mindestens Name, Instructions (Promp – textuelle Beschreibung der Aufgabe) und Kernel. Die Arguments-Konfiguration erlaubt es dem LLM, selbst zu entscheiden, ob es eine Plug-in-Funktion aufruft oder eine direkte Antwort generiert. Dieser Agent hier bekommt mit dem networkKernel Zugriff auf verschiedene netzwerknahe Implementierungen, also Plug-ins.

Der KI-Agent ist fertiggestellt. Jetzt fehlt nur noch der Aufruf des Agenten, um eine erste Interaktion zu starten (Listing 4).

Listing 4

<em>// erstelle ein ChatHistory object, um den Chatverlauf zu verwalten.</em>
ChatHistory chat = [];

<em>// F&#xFC;ge die User-Message hinzu</em>
chat.Add(new ChatMessageContent(AuthorRole.User, "<user input>"));

<em>// Generiere die Agent-Antwort(en)</em>
await foreach (ChatMessageContent response in agentNetworkChecker.InvokeAsync(chat))
{
<em>  //Verarbeite die Antwort(en)...</em>
}

Ein Agentensystem

Während ein einzelner KI-Agent bereits nützlich ist, entfaltet sich das volle Potenzial erst in einer Gruppe von Agenten. Hier arbeiten mehrere spezialisierte Agenten zusammen, um komplexe Aufgaben zu bewältigen. Für unser Analyseteam werden zusätzlich zum Network-Agent noch weitere Agenten benötigt, die ich hier nicht mehr detailliert aufführe. Das Grundprinzip bleibt jedoch gleich: Jeder Agent benötigt einen Namen, einen spezifischen Prompt und einen Kernel, der optional mit Plug-ins erweitert werden kann:

ChatCompletionAgent agentNetworkChecker = &#x2026; ; <em>// pr&#xFC;ft das Netzwerk</em>
ChatCompletionAgent agentCommonChecker = &#x2026; ; <em>// pr&#xFC;ft CPU, Storage, &#x2026;</em>
ChatCompletionAgent agentAnalyst = &#x2026; ; <em>// Analysiert die Ergebnisse der Agenten</em>
ChatCompletionAgent agentResolver = &#x2026; ; <em>// bewertet das Analyseergebnis</em>

Listing 5: GroupChat-Definition

AgentGroupChat groupChat =
new(agentAnalyst, agentNetworkChecker, agentResolver, agentCommonChecker)
{
ExecutionSettings = new()
{
SelectionStrategy = new KernelFunctionSelectionStrategy(selectionFct, kernel)
{
InitialAgent = agentAnalyst,
HistoryReducer = new ChatHistoryTruncationReducer(1),
HistoryVariableName = "lastmessage",
<em>//return the response from the current agent/or its name</em>
ResultParser = (result) =>{
var selection = result.GetValue<string>() ?? agentAnalyst.Name;
return selection;
}
},
TerminationStrategy = new KernelFunctionTerminationStrategy( terminationFct, kernel)
{
Agenten = new[] { agentResolver },
HistoryVariableName = "lastmessage",
HistoryReducer = new ChatHistoryTruncationReducer(1),<em>//last message</em>
MaximumIterations = 10, <em>// </em><em>maximum 10 rounds</em>
ResultParser = (recall) => <em>{//check agent response for presence of word &#x201C;YES&#x201D; </em>
var result =recall.GetValue<string>();
var yes = result?.ToLower().Contains("yes");
return yes ?? false;
}
}
}
};

Die SelectionStrategy legt fest, welcher Agent als nächstes antwortet. Dazu definieren wir Regeln, die sich an der letzten Nachricht orientieren (Listing 6).

Listing 6

KernelFunction selectionFct = AgentGroupChat.CreatePromptFunctionForStrategy(
$$$"""
**Task:** Determine which agent should act next based on the last response. Respond with **only** the agent's name from the list below. Do not add any explanations or extra text.

**Agenten:**

- {{{nameAnalyst}}}
- {{{nameNetworkChecker}}}
- {{{nameCommonChecker}}}
- {{{nameResolver}}}

**Selection Rules:**

- **If the last response is from the user:** Choose **{{{nameAnalyst}}} **.
- **If the last response is from {{{nameAnalyst}}}  and they are requesting network details:** Choose **{{{nameNetworkChecker}}}**.
- **If the last response is from {{{nameAnalyst}}}  and they are requesting non-network system checks:** Choose **{{{nameCommonChecker}}}**.
- **If the last response is from {{{nameAnalyst}}}  and they have provided an analysis report:** Choose **{{{nameResolver}}}**.
- **If the last response is from {{{nameNetworkChecker}}} or {{{nameCommonChecker}}}:** Choose **{{{{nameAnalyst}}} }**.
- **Never select the same agent who provided the last response.**

**Last Response:**

{{$lastmessage}}
""",
safeParameterNames: "lastmessage"
);

Die geschweiften Klammern {{{nameAnalyst}}} sind generell Platzhalter, die zur Laufzeit mit den tatsächlichen Agentennamen ersetzt werden. Das Muster {{{$}}} ist ein Platzhalter für Variableninhalte, die zur Laufzeit während des Chats eingefügt werden.

Hier ist es die Variable „ lastmessage“, die zuvor über das Feld HistoryVariableName der SelectionStrategy bekannt gemacht wurde. Beim Verwenden des Templates wird dort die ChatHistory vom Framework eingesetzt.

Die Zeile HistoryReducer = new ChatHistoryTruncationReducer(1) sorgt im Übrigen dafür, dass nur die letzte ChatMessage aus der Historie übergeben wird, da für die Selektion des nächsten Agenten ältere Nachrichten keine Relevanz haben. Zugleich spart dies Kosten, denn es reduziert die Anzahl der verwendeten Token, die derzeit die Währung der LLMs sind und mit der Länge des Texts in ihrer Menge steigen.

Die TerminationStrategy wird ähnlich wie die SelectionStrategy verwaltet. Sie legt fest, wann der Chat endet. Dazu wird das LLM angewiesen, eine Abschlussantwort zu geben, etwa „YES” oder „APPROVED”. Ein JSON-Schema erfasst diese Antwort strukturiert für die Automatisierungsprozesse. Zudem gibt es ein Fallback: Falls der Analyst ständig neue Details vom NetworkChecker anfordert und keine Entscheidung trifft, wird die Anzahl der Runden auf zehn begrenzt.

Unsere KI-Agenten sind nun vollständig – das Team kann Nachrichten verarbeiten, Entscheidungen treffen und den Chat sinnvoll beenden. Um unser Agenten-Team zu nutzen, fügen wir eine Nachricht hinzu und starten die asynchrone Verarbeitung. Die Antworten der Agenten werden dann in einer Schleife ausgegeben (Listing 7).

Listing 7

groupChat.AddChatMessage(new ChatMessageContent(AuthorRole.User, <User Input Nachricht>));
await foreach (ChatMessageContent response in groupChat.InvokeAsync())
{
Console.WriteLine($"{response.AuthorName.ToUpperInvariant()}:\n{response.Content}");
}

Mit diesem Konstrukt können wir diese KI-Agenten nun überall einbetten. Zum Beispiel in einem Support-Chatbot, einem automatisierten Incident-Management-System oder einer internen Analyse-Pipeline. In meinem GitHub-Projekt [1] findest du eine vollständige Implementierung mit einer interaktiven Schleife, in der Nutzer:innen direkt mit den Agenten kommunizieren können.

Fazit

KI-Agenten sind mehr als nur eine technologische Innovation – sie verändern die Art und Weise, wie wir Automatisierung und Entscheidungsfindung betrachten. Mit Semantic Kernel steht ein leistungsfähiges Werkzeug bereit, das es Entwickler:innen ermöglicht, intelligente Systeme zu bauen, die autonom zu einem gegebenen Problem nach einer Lösung suchen können.

Die Entwicklung in diesem Bereich schreitet rasant voran. Neue Modelle, verbesserte Orchestrierungsmechanismen und optimierte Agenten-Interaktionen werden in den kommenden Jahren die Möglichkeiten weiter ausbauen.

Links & Literatur

[1] https://github.com/totosan/tutorial-aiagents