Agenten

Das Prinzip: Denken, Handeln, Beobachten

Ein normaler Chat ist ein einziger Durchgang: Frage rein, Antwort raus. Ein Agent dagegen läuft in einer Schleife, bis er fertig ist oder abgebrochen wird:

Wichtig für das Verständnis: Das Modell „tut“ nie selbst etwas. Es schreibt nur – und ein Teil dessen, was es schreibt, wird vom Programm als Befehl interpretiert. Ob ein Befehl tatsächlich ausgeführt wird, entscheidet allein dieses Programm.

Ein Agent bei der Arbeit

Ein typischer Fall für einen Coding-Agenten. Geh Schritt für Schritt durch und achte darauf, wer jeweils handelt und wie sich das Kontextfenster füllt:

Was man daran sieht: Das Modell wusste anfangs nichts über das Projekt. Es hat sich die nötigen Informationen selbst beschafft, eine Vermutung gebildet, sie umgesetzt – und dann überprüft. Genau dieses Prüfen macht Agenten bei Code so stark: Der Compiler und die Tests liefern harte Rückmeldung, die Halluzinationen sofort auffliegen lässt.

Wie Werkzeuge funktionieren

Ein Werkzeug ist für das Modell nur eine Beschreibung, die im Kontextfenster steht: Name, Zweck und welche Parameter es erwartet – meist als JSON-Schema. Das Modell wurde darauf trainiert, bei Bedarf statt normalem Text einen passend formatierten Aufruf zu erzeugen.

{
  "name": "datei_lesen",
  "beschreibung": "Liest eine Datei aus dem Projekt und gibt ihren Inhalt zurück.",
  "parameter": { "pfad": { "type": "string" } }
}

{ "werkzeug": "datei_lesen", "pfad": "src/main/java/Rechnung.java" }

public class Rechnung {
    public BigDecimal brutto() { … }

Typische Werkzeuge sind Websuche, Dateien lesen und schreiben, Shell-Befehle, Code ausführen, einen Browser steuern, E-Mails oder Kalender, Datenbankabfragen. Damit nicht jede App jede Anbindung neu bauen muss, gibt es inzwischen Standards. Der verbreitetste ist das Model Context Protocol (MCP), 2024 von Anthropic vorgestellt und seitdem von vielen Anbietern übernommen: Ein Dienst stellt seine Werkzeuge einmal per MCP bereit, und jede kompatible KI-Anwendung kann sie nutzen.

Vom Chatbot zum Agenten

Der Übergang ist fließend. Man kann grob vier Stufen unterscheiden:

Warum lange Aufgaben schwer sind

Jeder Schritt eines Agenten kann schiefgehen: falsche Datei, falsch verstandene Ausgabe, eine erfundene Annahme. Wenn jeder Fehler unbemerkt durchrutscht, multiplizieren sich die Erfolgswahrscheinlichkeiten – und das wird bei vielen Schritten schnell bitter:

Dazu kommt das Kontextfenster: Jeder Werkzeugaufruf und jedes Ergebnis landet darin. Bei langen Aufgaben läuft es voll, und frühe Informationen müssen zusammengefasst oder ausgelagert werden – etwa in Notizdateien, die der Agent sich selbst schreibt und später wieder liest.

Risiken und Schutz

Ein Modell, das nur Text schreibt, kann wenig kaputt machen. Ein Agent mit Werkzeugen schon: Dateien löschen, Mails verschicken, Geld ausgeben. Drei Risiken stehen im Vordergrund:

Deshalb gelten bei Agenten ähnliche Grundsätze wie bei jedem Dienst mit Zugriffsrechten:

Für Entwickler übersetzt

// Die komplette Agentenschleife, im Kern
List<Nachricht> kontext = new ArrayList<>(List.of(systemprompt, werkzeugBeschreibungen, aufgabe));

while (true) {
    Antwort a = modell.senden(kontext);
    kontext.add(a);

    if (!a.hatWerkzeugaufruf()) {          // Modell ist fertig
        zeigeDemMenschen(a.text());
        break;
    }
    Aufruf call = a.werkzeugaufruf();
    if (istKritisch(call) && !menschBestaetigt(call)) {
        kontext.add(ergebnis(call, "Vom Benutzer abgelehnt."));
        continue;
    }
    String ergebnis = switch (call.name()) {
        case "datei_lesen"  -> dateien.lesen(call.arg("pfad"));
        case "shell"        -> sandbox.ausfuehren(call.arg("befehl"));
        case "web_suche"    -> suche.anfrage(call.arg("text"));
        default             -> "Unbekanntes Werkzeug";
    };
    kontext.add(ergebnis(call, ergebnis));  // zurück ins Kontextfenster
}

Mehr ist es im Kern nicht. Die Intelligenz steckt im Modell, die Kontrolle im Programm – und zwischen beiden fließt nur Text.

Häufige Irrtümer

Verwandte Begriffe