Agentic AI vs. Generative AI: Von der Erstellung von Inhalten zum aktiven Handeln

Agentische KI vs. generative KI: Von der Inhaltserstellung zum Handeln

Generative KI hat in den letzten Jahren die Diskussion über künstliche Intelligenz dominiert. Werkzeuge, die Essays schreiben, Bilder erzeugen und Code synthetisieren, sind aus beruflichen und privaten Arbeitsabläufen nicht mehr wegzudenken. Doch wenn wir uns die neuesten Entwicklungen von Organisationen wie OpenAI, Microsoft, Anthropic und NVIDIA ansehen, zeichnet sich ein neues, ehrgeizigeres Paradigma ab: **Agentische KI**. Statt lediglich Inhalte zu erzeugen, können agentische Systeme über ein Ziel nachdenken, eine Abfolge von Aktionen planen und diese über mehrere Tools und APIs hinweg ausführen.

Dieser Wandel ist mehr als nur ein Marketing-Schlagwort. Er definiert die Rolle der KI neu – von einem Assistenten, der auf Eingaben reagiert, hin zu einem autonomen Arbeiter, der Ziele verfolgt. In diesem Artikel klären wir den Unterschied zwischen generativer KI und agentischer KI, untersuchen praktische Implementierungswege und zeigen Ihnen, wie Sie mit echtem Code von der Inhaltserstellung zum Handeln übergehen.

Generative KI verstehen

Generative KI bezieht sich auf eine Klasse von Modellen – typischerweise große Sprachmodelle (LLMs) und Diffusionsmodelle – die darauf trainiert sind, neue Inhalte zu erzeugen. Diese Modelle lernen statistische Muster aus riesigen Datensätzen und nutzen sie, um Text, Bilder, Audio und Video basierend auf einer Benutzereingabe zu produzieren. Die Kernfunktion ist einfach: Bei einer Eingabe wird eine probabilistische Ausgabe erzeugt, die die Eingabe fortsetzt, transformiert oder vervollständigt.

Die bekanntesten Beispiele sind die GPT-Serie von OpenAI, die Claude-Modelle von Anthropic und NVIDIAs Arbeit an generativer KI-Infrastruktur. Generative KI glänzt bei Aufgaben wie dem Entwerfen von E-Mails, dem Zusammenfassen von Dokumenten, dem Übersetzen von Sprachen und dem Erstellen origineller Kunstwerke. Es handelt sich um eine einstufige Interaktion: Der Benutzer sendet eine Eingabeaufforderung, und das Modell gibt eine Antwort zurück. Selbst wenn ein System mehrere Aufrufe an das Modell enthält, bleibt jeder Aufruf unabhängig, sofern der Entwickler die Ergebnisse nicht explizit miteinander verknüpft.

Die grundlegende Einschränkung generativer KI besteht darin, dass sie im Kontext des Modells lebt. Sie kann über ein Dokument nachdenken, das in ihre Eingabeaufforderung gelegt wird, aber sie kann nicht im Internet surfen, eine Datenbank einsehen oder eine Datei ändern, es sei denn, diese Fähigkeiten werden manuell integriert und vom Entwickler orchestriert. Die Intelligenz ist generativ, nicht operativ.

Agentische KI einführen

Agentische KI erweitert generative KI um eine entscheidende Ergänzung: **Autonomie**. Ein Agent ist ein System, das ein LLM als zentrale „Denk-Engine“ nutzt, aber in eine Schleife eingebettet ist, die seine Umgebung wahrnimmt, Entscheidungen trifft und Aktionen ausführt. Wenn wir sagen, dass eine KI „agentisch“ ist, bedeutet das, dass sie ein Ziel mit minimalem menschlichem Eingriff verfolgen kann, dieses Ziel in Teilaufgaben zerlegt, externe Tools aufruft, die Ergebnisse auswertet und ihren Plan dabei anpasst.

Ein generatives KI-System kann beispielsweise einen Entwurf für einen Wochenbericht schreiben. Ein agentisches KI-System kann Verkaufsdaten aus Ihrem CRM sammeln, die Analysedatenbank abfragen, Diagramme erstellen, den Berichtstext schreiben, ein PDF erzeugen und es an die Führungsetage mailen – ganz ohne dass ein Mensch jeden Schritt entwirft.

Der Unterschied lässt sich in einem Satz zusammenfassen: **Generative KI erstellt Inhalte, während agentische KI Arbeitsabläufe ausführt.**

Führende Technologieunternehmen treiben diese Grenze aktiv voran. Der KI-Blog von Microsoft diskutiert, wie sich KI-Assistenten von einfachen Chat-Oberflächen zu Orchestrierungsebenen entwickeln, die Geschäftsprozesse koordinieren. Die News-Ankündigungen von Anthropic betonen Modellfähigkeiten, die Tool-Nutzung und langfristige Aufgaben unterstützen. NVIDIA hebt in seinem Blog über generative KI die Infrastruktur hervor, die erforderlich ist, um sowohl generative Inferenz als auch agentisches Denken in großem Maßstab zu unterstützen. Die Konvergenz ist klar: Die Branche arbeitet auf Systeme hin, die nicht nur reden, sondern handeln.

Hauptunterschiede: generativ vs. agentisch

| Aspekt | Generative KI | Agentische KI | |--------|---------------|---------------| | Kernfunktion | Inhalte erzeugen | Ziele erreichen | | Interaktionsmodell | Einzelner Eingabe-/Antwortzyklus | Mehrstufige Schleife mit Feedback | | Externe Tools | Meist keine | Ruft APIs, Datenbanken, Web, Dateien auf | | Gedächtnis | Auf Eingabekontext beschränkt | Dauerhafter Zustand über mehrere Schritte | | Fehlerbehandlung | Keine – einmaliger Versuch | Kann wiederholen, anpassen, neu planen | | Rolle des Menschen | Schreibt die Eingabeaufforderung | Legt das Ziel fest und überwacht |

Agentische KI ist kein Ersatz für generative KI; sie ist eine Obermenge. Jeder Agent ist für seine Denk- und Inhaltserzeugungsfähigkeiten auf ein generatives Modell angewiesen. Die Innovation liegt in der umgebenden Architektur: Der Agent entscheidet, *wann* er das Modell aufruft, *was* er mit der Ausgabe macht und *welche* Aktion er als Nächstes ausführt.

Aus praktischer Sicht bedeutet das, dass Entwickler eine neue Reihe von Werkzeugen benötigen. Statt eines einfachen API-Aufrufs müssen sie Orchestrierungsschleifen aufbauen, Tool-Schemas definieren, Zustände verwalten und Ausführungsfehler behandeln.

Voraussetzungen

Um den praktischen Beispielen in diesem Artikel zu folgen, benötigen Sie:

• **Python 3.9 oder höher**, installiert auf Ihrem System.
• Einen gültigen API-Schlüssel von einem Anbieter generativer KI. Die Beispiele verwenden die OpenAI-API, da sie weit verbreitet und in den News-Ankündigungen gut dokumentiert ist. Die gleichen Muster gelten für die Claude-API von Anthropic.
• `pip` zur Installation von Python-Paketen.
• Grundlegende Vertrautheit mit Python und Kommandozeilenwerkzeugen.

Wir werden einen minimalen Agenten von Grund auf bauen. Das Ziel ist es, die Architektur zu verstehen, nicht sich auf ein schwergewichtiges Framework zu verlassen. Sobald Sie die Schleife verstanden haben, können Sie Produktionsframeworks wie LangChain, CrewAI oder Microsofts AutoGen sicher übernehmen.

Schritt-für-Schritt-Installation

Erstellen Sie zuerst eine isolierte Python-Umgebung, um die Abhängigkeiten sauber zu halten:

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

Dies erstellt und aktiviert eine virtuelle Umgebung namens `venv`.

Installieren Sie als Nächstes das OpenAI-SDK, das wir für den Zugriff auf das generative Modell verwenden:

pip install openai

Das OpenAI-Paket bietet die Client-Schnittstelle für sowohl generative Vervollständigungen als auch agentische Tool-Aufrufmuster.

Setzen Sie nun Ihren API-Schlüssel als Umgebungsvariable. Ersetzen Sie `your-api-key` durch einen tatsächlichen Schlüssel von Ihrem Anbieter:

export OPENAI_API_KEY="your-api-key"

Den Schlüssel in einer Umgebungsvariable zu halten, vermeidet, ihn in Dateien hart zu codieren, und vereinfacht das Sicherheitsmanagement.

Überprüfen Sie die Installation, indem Sie die installierte Version ausgeben:

python -c "import openai; print(openai.__version__)"

Wenn der Befehl eine Versionsnummer ausgibt, können Sie fortfahren.

Verwendungsbeispiele

Schritt 1: Ein grundlegender generativer Aufruf

Beginnen wir mit dem klassischen generativen Muster: einer einzelnen Eingabeaufforderung und einer einzelnen Antwort.

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Write a two-sentence project summary."}
    ]
)

print(response.choices[0].message.content)

In diesem Code initialisieren wir den OpenAI-Client, senden eine Nachrichtenliste an das Modell und geben den zurückgegebenen Inhalt aus. Die Interaktion beginnt und endet innerhalb dieses einzelnen Aufrufs.

Schritt 2: Die agentische Schleife hinzufügen

Der Übergang von generativ zu agentisch wird erreicht, indem man den Modellaufruf in eine Schleife einbettet und dem Modell Zugriff auf Tools gibt. Hier ist eine minimale Implementierung:

import json
from openai import OpenAI

client = OpenAI()

# Define a simple tool: get the current weather for a city.
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a given city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name"}
                },
                "required": ["city"]
            }
        }
    }
]

def get_weather(city: str) -> str:
    """Mock implementation of a weather tool."""
    return f"The weather in {city} is 21°C with clear skies."

messages = [
    {"role": "user", "content": "What is the weather in Berlin? Provide one sentence."}
]

# Agentic loop: call the model, check for tool calls, execute them, repeat.
for _ in range(5):
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=tools,
    )

    message = response.choices[0].message

    # If the model asks for a tool, execute it and append the result.
    if message.tool_calls:
        messages.append(message)
        for tool_call in message.tool_calls:
            if tool_call.function.name == "get_weather":
                arguments = json.loads(tool_call.function.arguments)
                result = get_weather(arguments["city"])
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": result
                })
    else:
        # No tool call means the model is done.
        print(message.content)
        break

Schauen wir uns an, was hier passiert:

1. Das Modell erhält die Benutzerfrage sowie eine Deklaration des verfügbaren Tools. 2. Das Modell antwortet mit einem `tool_call`, der anzeigt, dass es `get_weather` mit `{"city": "Berlin"}` aufrufen möchte. 3. Unser Code führt die Funktion aus und fügt das Ergebnis als Tool-Nachricht zur Konversation hinzu. 4. Die Schleife wiederholt sich und sendet die angereicherte Konversation zurück an das Modell. 5. Dieses Mal nimmt das Modell das Wetter in seine Antwort auf und gibt regulären Inhalt zurück, sodass die Schleife endet.

Das ist das Wesen agentischer KI: Das System ruft aktiv eine externe Funktion auf, um Informationen zu sammeln, und verwendet diese Informationen dann, um sein Ziel zu erreichen.

Schritt 3: Ein Agent mit mehreren Schritten

Erweitern Sie das Muster zu einem etwas realistischeren Agenten, der sowohl Daten abrufen als auch eine Berechnung durchführen kann:

def calculate(expression: str) -> str:
    """Safely evaluate a math expression."""
    return str(eval(expression))

def fetch_document(url: str) -> str:
    """Mock fetching of a document."""
    return "Quarterly revenue is 1.4M USD across three regions."

Registrieren Sie diese zusammen mit `get_weather` in der `tools`-Liste. Fragen Sie den Agenten dann: *„Rufe den Quartalsbericht ab und berechne den Umsatz pro Region.“* Der Agent wird:

1. `fetch_document` aufrufen, um das Dokument zu lesen. 2. Feststellen, dass das Dokument „1,4 Mio. USD über drei Regionen“ besagt. 3. `calculate` mit `"1400000 / 3"` aufrufen. 4. `466666.67` zurückgeben.

Die Schleife übernimmt das gesamte Zwischenreasoning automatisch.

Vom Demo zur Produktion

Die minimale Schleife oben funktioniert, aber produktive agentische Systeme benötigen zusätzliche Komponenten:

• **Zustandsverwaltung**. Agenten müssen sich über lange Arbeitsabläufe hinweg Kontext merken. Verwenden Sie eine Datenbank, einen Vektor-Store oder eine strukturierte Gesprächshistorie.
• **Fehlerbehandlung und Wiederholungen**. APIs schlagen fehl, Tools liefern unerwartete Formate, und Modelle halluzinieren gelegentlich Tool-Argumente. Wickeln Sie Tool-Aufrufe in Try-Catch-Blöcke und fordern Sie das Modell bei Fehlern erneut auf.
• **Sicherheit und Schutzmaßnahmen**. Ein autonomer Agent kann irreversible Aktionen ausführen, wie das Senden von E-Mails oder das Löschen von Dateien. Fügen Sie Bestätigungsschritte, Berechtigungsprüfungen und Audit-Logs hinzu.
• **Beobachtbarkeit**. Da Agenten mehrere Entscheidungen treffen, verfolgen Sie jeden Schritt: die Eingabeaufforderung, den Tool-Aufruf, das Ergebnis und die Denkspur. Das macht das Debugging machbar.

Microsofts Blog betont, wie wichtig es ist, KI in größere Orchestrierungssysteme mit Governance auf Unternehmensebene zu integrieren. NVIDIAs Blog hebt den Bedarf an beschleunigter Infrastruktur hervor, um die erhöhte Rechenlast von iterativem Denken und Tool-Ausführung zu bewältigen. Sobald Sie über Demos hinausgehen, sind das keine optionalen Überlegungen.

Den richtigen Ansatz wählen

Sollten Sie ein generatives oder ein agentisches System bauen? Das hängt vom Problem ab.

Verwenden Sie **generative KI**, wenn die Aufgabe ein einzelner, klar definierter Schritt der Inhaltserzeugung ist:

• Produktbeschreibung schreiben.
• Langes Dokument zusammenfassen.
• Benutzernachricht übersetzen.
• Codeausschnitt generieren.

Verwenden Sie **agentische KI**, wenn die Aufgabe mehrere aufeinanderfolgende Schritte, externe Daten oder autonome Entscheidungsfindung umfasst:

• Posteingang überwachen und dringende E-Mails priorisieren.
• Einen Markt recherchieren, Ergebnisse zusammenstellen und eine Präsentation vorbereiten.
• Fehlgeschlagene CI-Builds automatisch beheben, indem Logs gelesen, Code geändert und Tests ausgeführt werden.
• Kundensupport-Tickets durchgängig bearbeiten.

Eine einfache Faustregel: Wenn Sie das Ergebnis mit einem einzigen Aufruf an ein LLM erreichen können, bleiben Sie generativ. Wenn die Aufgabe eine Schleife von Aktionen erfordert, ziehen Sie einen Agenten in Betracht.

Der Weg nach vorn

Die Grenze zwischen generativer und agentischer KI wird weiter verschwimmen. Zukünftige Modelle werden nativ Planung über lange Zeiträume und Tool-Nutzung unterstützen. Anbieter wie OpenAI und Anthropic liefern bereits APIs, die für agentische Arbeitsabläufe entwickelt wurden, einschließlich Schnittstellen für Tool-Aufrufe und strukturierte Ausgaben. Microsoft integriert diese Fähigkeiten in Produktivitätstools, während NVIDIA den Hardware- und Software-Stack aufbaut, um Echtzeit-Agentenlogik kosteneffizient zu machen.

Für Entwickler ist die Botschaft klar: Meistern Sie die Grundlagen der generativen KI, aber investieren Sie Zeit in das Lernen agentischer Muster. Die Fähigkeit, Systeme zu bauen, die handeln – statt lediglich Inhalte zu produzieren – wird die nächste Welle von KI-Anwendungen definieren.

Fazit

Generative KI verwandelt Eingabeaufforderungen in Inhalte. Agentische KI verwandelt Ziele in Ergebnisse. Das eine ist ein Taschenrechner für Wörter und Bilder; das andere ist ein Arbeiter, der plant, Werkzeuge verwendet und ausführt. Der Wechsel von Generierung zu Handlungsfähigkeit ist nicht nur ein technisches Upgrade – es ist eine Änderung darin, wie wir die Rolle der KI in unserer Arbeit und unserem Leben definieren.

Mit der einfachen Python-Schleife, die wir oben gebaut haben, haben Sie die Schwelle bereits überschritten. Indem Sie Tool-Definitionen, eine Entscheidungsschleife und eine elegante Fehlerbehandlung hinzufügen, können Sie über das hinausgehen, eine KI für Sie schreiben zu lassen, und sie stattdessen für Sie handeln lassen. Die Infrastruktur von NVIDIA, die APIs von OpenAI und Anthropic und die Orchestrierungsplattformen von Microsoft laufen alle auf diese Vision hinaus. Die praktische Frage ist nicht mehr, ob KI handeln kann; es ist, ob Sie die Systeme bauen werden, die es ihr ermöglichen.