Agentische KI: Die nächste Evolution über die generative KI hinaus

Agentische KI: Die nächste Evolution über generative KI hinaus

Wenn Sie die Entwicklungen im Bereich des maschinellen Lernens in den letzten Jahren verfolgt haben, wissen Sie bereits, wie dramatisch generative KI Arbeitsabläufe verändert hat. Modelle, die Text, Bilder, Code und Audio erzeugen, haben sich von Forschungskuriositäten zu Produktionssystemen entwickelt, die von Millionen genutzt werden. Doch die Branche verlagert ihren Fokus bereits wieder. Die nächste Evolution ist *agentische KI* – Systeme, die nicht nur Inhalte generieren, sondern planen, schlussfolgern und eigenständig handeln, um mehrstufige Aufgaben zu erledigen.

Die großen Anbieter, die diesen Wandel verfolgen – NVIDIA über seine Entwickler- und KI-Blogs, OpenAI über sein Newsroom, Microsoft über seinen KI-Forschungsblog und Anthropic über seine Produkt- und Sicherheitsankündigungen – weisen alle in eine gemeinsame Richtung. Der Wert von KI liegt nicht länger nur in der Antwort, die sie produziert; er liegt in der Arbeit, die sie autonom erledigen kann. Dieser Artikel erklärt, was agentische KI ist, warum sie wichtig ist und wie Sie noch heute mit kostenlosen, offenen Werkzeugen eigene Agenten bauen können.

Der Wandel: Vom Antworten zum Handeln

Generative KI-Modelle werden darauf trainiert, das nächste Token in einer Sequenz vorherzusagen. Geben Sie ihnen einen Prompt, und sie antworten mit einer plausiblen Fortsetzung. Diese eine Fähigkeit treibt Chatbots, Copiloten, Zusammenfasser und Bildgeneratoren an. All das sind *reaktive* Systeme: Sie warten auf Eingaben, erzeugen Ausgaben und stoppen.

Agentische KI verändert das Interaktionsmodell grundlegend. Anstatt auf einen einzelnen Prompt zu reagieren, erhält ein Agent ein *Ziel* und entscheidet dann, welche Schritte er unternehmen muss, um dieses Ziel zu erreichen. Er kann die Aufgabe in Unteraufgaben zerlegen, externe Werkzeuge aufrufen, Informationen aus dem Web oder aus Datenbanken abrufen, Code schreiben und ausführen, die Ergebnisse seiner eigenen Aktionen überprüfen und iterieren, bis das Ziel erreicht ist.

Ein agentisches System hat eine Schleife, grob skizziert:

1. Beobachte den aktuellen Zustand. 2. Überlege, welche Aktion als Nächstes ausgeführt werden soll. 3. Führe diese Aktion aus (z. B. ein Werkzeug aufrufen, ein Skript ausführen, eine Datenbank abfragen). 4. Beobachte das Ergebnis. 5. Wiederhole, bis das Ziel erfüllt ist.

Dies ist das klassische ReAct-Paradigma (Reasoning + Acting) und das architektonische Rückgrat der meisten modernen Agent-Frameworks. Das zugrunde liegende Modell ist immer noch ein generatives Modell – aber das *System darum herum* macht die KI agentisch.

Kernfähigkeiten eines Agenten

Um ein System als „agentisch" zu bezeichnen, achte ich auf vier Fähigkeiten:

**Werkzeugnutzung.** Der Agent kann externe Funktionen aufrufen – Websuchen, Code-Interpreter, Taschenrechner, REST-APIs, Dateisystemoperationen. Dies ist das definierende Merkmal, weil es dem Modell ermöglicht, die reale Welt zu beeinflussen. Das Modell behauptet nicht nur „Das Wetter in Lissabon ist sonnig"; es ruft eine Wetter-API auf und überprüft die Antwort.

**Planung.** Angesichts eines übergeordneten Ziels kann der Agent es in eine Sequenz ausführbarer Schritte zerlegen, diese bei Bedarf neu anordnen und aus Fehlern mitten im Plan wieder aufstehen.

**Gedächtnis.** Ein Agent braucht sowohl ein Kurzzeitgedächtnis (den aktuellen Gesprächs- und Aufgabenstatus) als auch ein Langzeitgedächtnis (Embeddings vergangener Interaktionen oder Wissen, das in einer Vektordatenbank gespeichert ist). Das Gedächtnis ermöglicht Kohärenz über lange, mehrstündige Aufgaben hinweg.

**Selbstreflexion.** Der Agent bewertet seine eigenen Ausgaben. Er kann einen Test gegen generierten Code ausführen, sehen, dass der Test fehlschlägt, und es mit einem anderen Ansatz erneut versuchen. Das schließt den Regelkreis und macht das System für komplexe Aufgaben wirklich nützlich, anstatt nur ein Einmal-Generator zu sein.

Wenn diese vier Fähigkeiten kombiniert werden, wird ein KI-System eher zu einem autonomen Mitarbeiter als zu einem Chatbot.

Voraussetzungen

Um die folgenden praktischen Beispiele nachzuvollziehen, benötigen Sie einen Rechner mit Folgendem:

• **Betriebssystem:** Linux, macOS oder Windows (Windows-Benutzer sollten für ein reibungsloses Erlebnis WSL2 installieren).
• **Python 3.10 oder neuer** – Python ist die primäre Sprache für Agent-Frameworks.
• **~8 GB freier RAM** – genug, um ein bescheidenes lokales Sprachmodell auszuführen. Für größere Modelle werden 16 GB oder mehr empfohlen.
• **Ein kostenloser API-Schlüssel** (optional, aber empfohlen), falls Sie lieber ein gehostetes Modell anstelle eines lokalen verwenden. In den folgenden Beispielen verwende ich ein lokales Modell über Ollama, sodass kein Cloud-API-Schlüssel erforderlich ist.
• **Git** (optional, zum Klonen von Repositorys).

Der zentrale Software-Stack, den wir verwenden:

• **Ollama** – eine minimale Laufzeitumgebung, die Open-Weight-Modelle (Llama, Mistral, Qwen usw.) lokal ausführt und eine OpenAI-kompatible API bereitstellt.
• **Python-Pakete:** `openai` (das offizielle SDK, das nicht nur mit OpenAI-Endpunkten funktioniert, sondern mit jedem OpenAI-kompatiblen Server), `python-dotenv` für die Verwaltung von Geheimnissen und optional `langchain` oder `crewai` für stärkere Abstraktion. In diesem Artikel verzichte ich auf schwere Frameworks und zeige Ihnen eine minimale Agent-Schleife, die Ihnen volle Einblicke in das Geschehen ermöglicht.

Schritt-für-Schritt-Installation

Alle folgenden Befehle sind für eine Bash-Shell unter Linux/macOS (oder WSL2 unter Windows) gedacht.

1. Ollama installieren

Ollama ist der einfachste Weg, einen lokalen, OpenAI-kompatiblen Modell-Endpunkt zu erhalten. Unter Linux und macOS führen Sie aus:

curl -fsSL https://ollama.com/install.sh | sh

Wenn die Installation abgeschlossen ist, starten Sie den Ollama-Server im Hintergrund:

ollama serve

Lassen Sie dieses Terminal offen oder führen Sie es als Dienst aus. Der Server lauscht standardmäßig auf `http://localhost:11434`.

2. Ein Modell laden

Laden Sie als Nächstes ein leistungsfähiges, instruktionsoptimiertes Modell herunter. Ein guter Ausgangspunkt, der mit 8 GB RAM läuft, ist `llama3.1:8b`:

ollama pull llama3.1:8b

Wenn Sie einen kleineren Rechner haben, ist `qwen2.5:3b` ebenfalls geeignet. Überprüfen Sie, ob das Modell antwortet:

ollama run llama3.1:8b "Say hello in one sentence."

Sie sollten eine kurze Begrüßung sehen. Drücken Sie Strg+D oder geben Sie `/bye` ein, um die Chat-Oberfläche zu verlassen.

3. Die Python-Umgebung einrichten

Erstellen Sie ein Verzeichnis für Ihr Agent-Projekt und eine virtuelle Umgebung:

mkdir ~/agentic-demo && cd ~/agentic-demo
python3 -m venv venv
source venv/bin/activate

Die virtuelle Umgebung isoliert Ihre Abhängigkeiten vom Rest des Systems.

4. Die erforderlichen Python-Pakete installieren

Wir benötigen das OpenAI-Python-SDK, um mit Ollamas OpenAI-kompatiblem Endpunkt zu kommunizieren:

pip install --upgrade openai python-dotenv

Das `openai`-Paket funktioniert mit Ollama, wenn wir die `base_url` überschreiben. Das Paket `python-dotenv` ist hier nicht unbedingt erforderlich, aber nützlich, wenn Sie später ein gehostetes Modell mit einem API-Schlüssel einbinden möchten.

Anwendungsbeispiele: Einen minimalen Agenten bauen

Nun kommen wir zum Kern dieses Artikels. Wir werden einen winzigen, aber voll funktionsfähigen Agenten in reinem Python bauen. Er nutzt die *Tool-Calling*-Fähigkeit des Llama-Modells, um zu entscheiden, wann er einen Taschenrechner verwenden soll, ruft eine lokale Python-Funktion auf und liefert dann eine endgültige Antwort.

Die Agent-Schleife

Erstellen Sie eine Datei namens `agent.py`:

import json
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # vom SDK benötigt, ein beliebiger String funktioniert
)

MODEL = "llama3.1:8b"

# ----------------------------------------------------------------------
# 1. Die dem Agenten zur Verfügung stehenden Werkzeuge definieren
# ----------------------------------------------------------------------

def calculator(expression: str) -> float:
    """Evaluiert einen einfachen arithmetischen Ausdruck sicher."""
    # Nur Zahlen, Operatoren und Leerzeichen zulassen
    allowed = set("0123456789+-*/(). ")
    if not all(c in allowed for c in expression):
        raise ValueError("Nicht erlaubte Zeichen im Ausdruck")
    return eval(expression, {"__builtins__": {}}, {})  # noqa: S307 - oben bereinigt

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "calculator",
            "description": "Evaluiert einen numerischen arithmetischen Ausdruck.",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "Der auszuwertende Ausdruck, z. B. '3 * (2 + 5)'",
                    }
                },
                "required": ["expression"],
            },
        },
    }
]

# ----------------------------------------------------------------------
# 2. Hauptschleife des Agenten
# ----------------------------------------------------------------------

def run_agent(user_prompt: str, max_iterations: int = 5) -> None:
    messages = [{"role": "user", "content": user_prompt}]

    for step in range(max_iterations):
        print(f"\n--- Schritt {step + 1} ---")

        response = client.chat.completions.create(
            model=MODEL,
            messages=messages,
            tools=TOOLS,
        )

        message = response.choices[0].message

        # Das Modell kann uns bitten, ein Werkzeug aufzurufen
        if message.tool_calls:
            messages.append(message)

            for tool_call in message.tool_calls:
                fn_name = tool_call.function.name
                args = json.loads(tool_call.function.arguments)
                print(f"  [Agent] ruft {fn_name}({args}) auf")

                if fn_name == "calculator":
                    result = calculator(args["expression"])
                else:
                    result = "Unbekanntes Werkzeug"

                # Das Werkzeugergebnis an das Modell zurücksenden
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": str(result),
                })
                print(f"  [Tool]  gab {result} zurück")
            continue  # Schleife erneut durchlaufen, damit das Modell eine endgültige Antwort erzeugen kann

        # Keine Tool-Aufrufe -> endgültige Antwort
        print(f"  [Antwort] {message.content}")
        break
    else:
        print("Maximale Iterationen erreicht, ohne eine endgültige Antwort zu erhalten.")


if __name__ == "__main__":
    prompt = (
        "Was ist das Ergebnis von (1234 * 4321) - (99 / 3)? "
        "Nutze das Taschenrechner-Werkzeug und gib mir dann die endgültige Zahl."
    )
    run_agent(prompt)

Den Agenten ausführen

Aktivieren Sie Ihre Umgebung und führen Sie das Skript aus:

source venv/bin/activate
python agent.py

Was passieren sollte, ist genau die agentische Schleife, die am Anfang dieses Artikels beschrieben wurde:

1. Das Modell erhält die Rechenaufgabe. 2. Es erkennt, dass es das Produkt nicht zuverlässig berechnen kann, und ruft das Werkzeug `calculator` mit einem Ausdruck auf. 3. Das Werkzeug gibt die Zahl zurück. 4. Das Modell erhält diese Zahl und gibt eine endgültige, überprüfte Antwort aus.

Das gedruckte Transkript wird ungefähr so aussehen:

--- Schritt 1 ---
  [Agent] ruft calculator({'expression': '(1234 * 4321) - (99 / 3)'}) auf
  [Tool]  gab 5332759.0 zurück
--- Schritt 2 ---
  [Antwort] Das Ergebnis von (1234 × 4321) - (99 ÷ 3) ist 5.332.759.

Den Agenten erweitern

Das Muster skaliert. Um Ihrem Agenten weitere Fähigkeiten zu geben, fügen Sie einfach weitere Funktionen zur `TOOLS`-Liste und weitere Verzweigungen im Tool-Aufrufblock hinzu. Sie können beispielsweise ein `web_search`-Werkzeug hinzufügen, das eine Such-API aufruft, ein `read_file`-Werkzeug oder ein `run_python`-Werkzeug, das beliebigen Sandbox-Code ausführt.

Ein produktionsreiferer Ansatz ist die Verwendung eines Frameworks wie LangGraph, CrewAI oder des OpenAI Agents SDK, die Gesprächszustand, parallele Tool-Aufrufe und Human-in-the-Loop-Checkpoints für Sie übernehmen. Aber die minimale Schleife oben ist ideal, um zu verstehen, was diese Frameworks unter der Haube tun. Sobald Sie diese zehnschrittige Schleife sehen, sind Agent-Frameworks keine Magie mehr.

Die Landschaft: Von Copiloten zu Mitarbeitern

Der Wandel von generativer zu agentischer KI ist nicht nur eine technische Übung; es ist eine Veränderung darin, wie Unternehmen über Automatisierung denken. Während der generativen Ära erforderten Produkte wie Chatbots und Copiloten, dass ein Mensch für jeden bedeutenden Schritt im Loop blieb. Die neuesten Ankündigungen von OpenAI, Anthropic und Microsoft betonen alle Agenten, die über längere Zeiträume und mit größerer Unabhängigkeit arbeiten. Microsofts KI-Blog stellt KI beispielsweise konsequent als „Arbeitsassistenten" dar, der in Ihrem Namen handelt, während die News- und Sicherheitsseiten von Anthropic dem Thema „Computernutzung" und verantwortungsvoller agentischer Werkzeuginteraktion viel Raum widmen. NVIDIA wiederum betrachtet Agenten als die nächste Arbeitslast, die sowohl Modelleffizienz als auch Rechenzentrumsnachfrage antreibt, wobei der Entwicklerblog den gesamten Stack aus Frameworks, GPUs und Inferenzsoftware verfolgt, der Multi-Agent-Systeme praktikabel macht.

Diese Konvergenz ist ein starkes Signal: Die Branche glaubt, dass die nächste Phase des KI-Werts nicht aus generierten Artefakten entstehen wird, sondern aus *erreichten Ergebnissen*.

Es ist auch wichtig, die offenen Herausforderungen klar zu sehen. Agentische Systeme sind komplexer zu bewerten. Eine einzelne Chat-Antwort kann anhand ihrer Kohärenz beurteilt werden; ein Agent muss anhand der Aufgabenerledigungsrate, der Kosten pro erfolgreicher Aufgabe und der Sicherheit beurteilt werden. Sie führen auch neue Fehlermodi ein: Ein Tool-Aufruf kann fehlschlagen, ein Plan kann entgleisen, oder ein Modell kann eine Funktion halluzinieren, die es nicht gibt. Das Design von Produktionssystemen stützt sich daher stark auf Schutzmechanismen: erlaubte Tool-Whitelists, Nur-Lese-Modi, Token-Budgets und Genehmigungs-Checkpoints durch Menschen für Aktionen mit großer Auswirkung. Wie die Schriften von Anthropic zur KI-Sicherheit argumentieren: Je mehr Autonomie wir Modellen gewähren, desto rigoroser muss unsere Arbeit an Ausrichtung und Evaluierung werden.

Wenn Sie beginnen, sich von generativer zu agentischer KI zu bewegen, ist dies der pragmatische Weg, den ich empfehle:

1. **Meistern Sie die minimale Schleife.** Tun Sie genau das, was wir oben getan haben: ein Modell, ein Werkzeug, ein klares Ziel. 2. **Fügen Sie Werkzeuge schrittweise hinzu** – Websuche, Vektorgedächtnis, Codeausführung – und beobachten Sie, wo das Modell Erfolg hat und wo es scheitert. 3. **Fügen Sie Beobachtbarkeit hinzu.** Protokollieren Sie jeden Prompt, jeden Tool-Aufruf und jedes Ergebnis. Agentische Systeme sind debug-intensiv, und Sie werden sich für gutes Tracing danken. 4. **Wechseln Sie dann zu Frameworks**, sobald Sie die Schleife verstehen. Sie werden deren Dokumentation mit echtem Verständnis lesen können, anstatt ihre Abstraktionen als Black Boxes zu behandeln.

Fazit

Generative KI hat uns Modelle gegeben, die Wörter, Bilder und Code verfassen können. Agentische KI nimmt diese rohe Fähigkeit und verpackt sie in eine Schleife aus Planung, Werkzeugnutzung, Gedächtnis und Reflexion – und verwandelt ein Modell in einen Akteur in einer Welt aus APIs und Dateien. Das Ergebnis ist ein Wandel von „frag mich alles" zu „erledige es".

Die technologische Infrastruktur für diesen Übergang ist jetzt für jeden Entwickler mit einem Laptop zugänglich. Mit Ollama, einem lokalen Open-Weight-Modell und etwa vierzig Zeilen Python können Sie einen Agenten bauen, der denkt, Werkzeuge aufruft, Ergebnisse überprüft und eine Aufgabe Ende-zu-Ende erledigt. Die Ökosystemführer – NVIDIA, OpenAI, Microsoft und Anthropic – bauen alle auf derselben grundlegenden Prämisse auf: Dass denkende Modelle in Kombination mit Aktionsschleifen das nächste Jahrzehnt der angewandten künstlichen Intelligenz definieren werden. Die Frage ist nicht mehr, *ob* KI handeln wird; es ist, *wie gut* wir ihr beibringen können, sicher, zuverlässig und im Dienst echter menschlicher Ziele zu handeln.