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

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

Wenn du dich auch nur ansatzweise mit der Entwicklung künstlicher Intelligenz beschäftigst, bist du wahrscheinlich auf zwei Begriffe gestoßen, die ineinander überzugehen scheinen: *generative KI* und *agentische KI*. Briefings großer Forschungseinrichtungen – darunter der NVIDIA-Entwicklerblog, die Newsroom-Seite von OpenAI und der Microsoft AI Blog – behandeln diese zunehmend als separate Meilensteine. Für Praktiker wirkt die Grenze jedoch oft verschwommen.

Generative KI erzeugt Inhalte – Text, Bilder, Code, Audio – auf der Grundlage von Mustern, die aus Trainingsdaten gelernt wurden. Agentische KI hingegen produziert nicht nur eine Antwort; sie handelt. Sie plant, nutzt Werkzeuge, zerlegt ein Ziel in Schritte, ruft externe APIs auf und iteriert, bis das Ziel erreicht ist. Dieser Artikel erklärt den Unterschied, zeigt dir, wie du eine funktionierende Umgebung für beides einrichtest, und führt dich durch praktische Beispiele, damit du in deinem eigenen Terminal den Wandel von der „Inhaltserstellung" zum „autonomen Handeln" siehst.

---

Von der Generierung zum Handeln

Generative KI ist das, was die meisten Menschen zuerst kennengelernt haben. Wenn du ein großes Sprachmodell (LLM) bittest, eine Zusammenfassung zu schreiben, eine E-Mail zu entwerfen oder ein Python-Skript zu generieren, erzeugt es eine statistisch plausible Sequenz von Token. Das Modell ist eine Inhaltsmaschine. Es reagiert auf eine Eingabeaufforderung und stoppt dann. Alles danach – das Kopieren der Antwort, das Einfügen in ein System, das Ausführen des Codes – liegt bei dir.

Agentische KI kehrt dieses Verhältnis um. Statt dass der Mensch auf die Ausgabe der Maschine reagiert, handelt die Maschine auf der Grundlage der Absicht des Menschen. Ein agentisches System erhält ein übergeordnetes Ziel, etwa „Analysiere unsere Verkaufsdaten und sende mir wöchentlich eine Zusammenfassung per E-Mail." Es entscheidet dann, welche Werkzeuge es verwendet, ruft die Daten ab, führt die Analyse durch, verfasst die Zusammenfassung und sendet die E-Mail – mit minimaler menschlicher Intervention.

Die News-Seite von Anthropic und die Ankündigungen von OpenAI beschreiben eine stetige Entwicklung in diese Richtung: Modelle, die Werkzeuge nutzen, Funktionen aufrufen und mehrere Schritte miteinander verketten können. Das Modell wird weniger wie eine Schreibmaschine und mehr wie ein Teammitglied, das weiß, wie man delegiert, Ergebnisse prüft und den Kurs ändert, wenn ein Ansatz fehlschlägt. Wie der Microsoft AI Blog festgestellt hat, verlagert sich KI dadurch von der Vorschlagserstellung zur Ausführung von Arbeitsabläufen.

Der Kernunterschied lässt sich wie folgt zusammenfassen:

• **Generative KI** beantwortet *„Was soll ich sagen?"*
• **Agentische KI** beantwortet *„Was soll ich tun?"* – und tut es dann.

Beide basieren auf denselben zugrunde liegenden Transformer-Modellen. Der Unterschied liegt in der Architektur, den Werkzeugen und dem Kontrollfluss.

---

Voraussetzungen

Um die Installation und die Beispiele in diesem Artikel nachvollziehen zu können, benötigst du:

• **Python 3.10 oder neuer** (idealerweise in einer virtuellen Umgebung installiert)
• **`pip`** für die Paketinstallation
• **Einen OpenAI-API-Schlüssel** (oder einen alternativen LLM-Anbieter wie Anthropic oder ein lokales Modell über Ollama)
• **Internetzugang**, um Pakete herunterzuladen und APIs aufzurufen
• **Grundlegende Vertrautheit mit der Befehlszeile**

Die folgenden Beispiele verwenden das OpenAI-Python-SDK und das LangChain-Framework. Außerdem verwenden wir `requests` für einen einfachen HTTP-basierten Tool-Aufruf. Wenn du bereits Python installiert hast, kannst du deine Version überprüfen mit:

python --version

Wenn dieser Befehl eine Versionsnummer unter 3.10 zurückgibt oder einen Fehler meldet, installiere zuerst eine aktuelle Version von Python von der offiziellen Website, bevor du fortfährst.

---

Schritt-für-Schritt-Installation

1. Eine virtuelle Umgebung erstellen

Eine virtuelle Umgebung hält Abhängigkeiten von deinem System-Python getrennt. Das verhindert Versionskonflikte zwischen Projekten.

python -m venv agentic_env

Nachdem du diesen Befehl ausgeführt hast, wird in deinem aktuellen Ordner ein neues Verzeichnis namens `agentic_env` erstellt.

2. Die virtuelle Umgebung aktivieren

Die Aktivierung ändert den Pfad deiner Shell, sodass `python` und `pip` auf die lokalen Versionen der Umgebung zeigen.

Unter Linux oder macOS:

source agentic_env/bin/activate

Unter Windows (Eingabeaufforderung oder PowerShell):

agentic_env\Scripts\activate

Deine Eingabeaufforderung sollte jetzt `(agentic_env)` als Präfix anzeigen.

3. Die erforderlichen Python-Pakete installieren

Wir installieren das OpenAI-SDK, LangChain-Integrationspakete und einige Hilfsprogramme.

pip install openai langchain langchain-openai langchain-community python-dotenv requests

Hier ist, wofür jedes Paket gedacht ist:

• `openai` – offizielles SDK zum Aufrufen von OpenAI-Modellen.
• `langchain` – Framework zum Erstellen von Ketten und agentischen Workflows.
• `langchain-openai` – OpenAI-Integrationswerkzeuge für LangChain.
• `langchain-community` – von der Community beigesteuerte Werkzeuge und Wrapper.
• `python-dotenv` – lädt API-Schlüssel aus einer `.env`-Datei.
• `requests` – führt HTTP-Aufrufe für unser Werkzeugbeispiel aus.

4. Deinen API-Schlüssel festlegen

Erstelle eine Datei namens `.env` im selben Verzeichnis. Die `.env`-Datei verhindert, dass du Geheimnisse direkt in deine Skripte schreibst.

echo "OPENAI_API_KEY=your-key-here" > .env

Ersetze `your-key-here` durch deinen tatsächlichen OpenAI-API-Schlüssel. Wenn du einen anderen Anbieter verwendest, passe den Variablennamen und die Modellnamen in den folgenden Beispielen entsprechend an.

5. Die Installation überprüfen

Führe einen schnellen Importtest aus, um sicherzustellen, dass alle Pakete erreichbar sind.

python -c "import openai, langchain; print('OK')"

Wenn du `OK` siehst, ist die Umgebung bereit.

---

Anwendungsbeispiele

Wir werden nun zwei Skripte schreiben, die den Unterschied zwischen generativer und agentischer KI verdeutlichen. Das erste Skript ist rein generativ: Es fragt nach Inhalten und gibt sie aus. Das zweite Skript baut einen minimalen Agenten, der eine Aufgabe durch den Aufruf eines Werkzeugs ausführt.

Beispiel 1: Generative KI – nur Inhaltserstellung

Erstelle eine Datei mit dem Namen `generate.py`:

from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI()

prompt = "Write a concise, professional one-paragraph summary of the benefits of using AI-powered developer tools."

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a technical writer."},
        {"role": "user", "content": prompt},
    ],
    max_tokens=300,
)

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

Führe das Skript aus:

python generate.py

Das Programm sendet die Benutzernachricht an das Modell, erhält Text als Antwort und gibt ihn aus. Das war's. Das Skript hat keine Erinnerung über die in der Anfrage enthaltenen Nachrichten hinaus. Es gibt keine Folgeaktion. Die Ausgabe ist statisch. Wenn du den generierten Text in einer anderen Anwendung verwenden möchtest, musst du ihn kopieren oder zusätzlichen Code schreiben, um ihn zu verarbeiten. Das ist klassische generative KI: eine Eingabeaufforderung, eine Ausgabevervollständigung und ein menschliches Bindeglied dazwischen.

Beispiel 2: Agentische KI – Planung, Werkzeugnutzung und autonomes Handeln

Jetzt bauen wir einen minimalen Agenten. Der Agent erhält ein Ziel, entscheidet, welches Werkzeug er aufruft, liest das Ergebnis des Werkzeugs und erstellt eine endgültige Antwort. Um das Beispiel ohne zusätzliche Abhängigkeiten zu halten, verwenden wir ein einfaches Rechnerwerkzeug, das als Python-Funktion bereitgestellt wird.

Erstelle eine Datei mit dem Namen `agent.py`:

import json
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, ToolMessage
from langchain_core.tools import tool

load_dotenv()

# Define a tool the agent can call.
@tool
def multiply(a: int, b: int) -> int:
    """Multiply two integers and return the product."""
    return a * b

# Define a second tool.
@tool
def add(a: int, b: int) -> int:
    """Add two integers and return the sum."""
    return a + b

# Register both tools with the model.
tools = [multiply, add]

model = ChatOpenAI(model="gpt-4o-mini")
model_with_tools = model.bind_tools(tools)

# The goal: perform a small arithmetic calculation.
messages = [
    HumanMessage(content="What is 7 multiplied by 8, plus 9? Use the tools when appropriate.")
]

# Step 1: Ask the model what to do.
response = model_with_tools.invoke(messages)

# Step 2: If the model requested tool calls, execute them.
if response.tool_calls:
    for tool_call in response.tool_calls:
        selected_tool = {"multiply": multiply, "add": add}[tool_call["name"]]
        result = selected_tool.invoke(tool_call["args"])
        # Append the tool output to the conversation history.
        messages.append(ToolMessage(content=str(result), tool_call_id=tool_call["id"]))
    # Step 3: Ask the model again, now with tool results in hand.
    final_response = model_with_tools.invoke(messages)
    print(final_response.content)
else:
    print(response.content)

Führe den Agenten aus:

python agent.py

Die erwartete Ausgabe ist in etwa:

65

oder, falls das Modell eine Erklärung wählt:

7 multiplied by 8 is 56, and adding 9 gives 65.

Wichtiger als die konkrete Antwort ist der Arbeitsablauf. Der Agent hat nicht einfach in einem einzigen Durchgang Text erzeugt. Er erhielt ein Ziel, gab eine strukturierte Anfrage zum Aufruf von `multiply(7, 8)` aus, erhielt das Ergebnis (`56`), rief dann `add(56, 9)` auf (oder berechnete die Summe direkt mit dem zurückgegebenen Wert), erhielt `65` und formulierte schließlich eine Antwort in natürlicher Sprache. Das Modell fungierte als Steuerung, die entschied, was zu tun ist, es tatsächlich tat und das Ergebnis überprüfte.

Wenn ein Werkzeugaufruf fehlgeschlagen wäre oder einen unerwarteten Wert zurückgegeben hätte, könnte der Agent damit umgehen, indem er ein anderes Werkzeug aufruft oder um Klärung bittet. Diese geschlossene Schleife – *Handlung, Beobachtung, Fortsetzung* – ist das Wesen agentischen Verhaltens.

Den Agenten auf externe APIs erweitern

Das gleiche Muster funktioniert mit Web-APIs. Du könntest zum Beispiel ein Werkzeug definieren, das eine Wetter-API oder eine Datenbankabfrage aufruft. Der Agent würde die Werkzeugfunktion aufrufen, die Funktion würde mit `requests` eine HTTP-Anfrage durchführen, und das Ergebnis würde an das Modell zurückgegeben. Ein so aufgebautes agentisches System kann wirklich mit der Außenwelt interagieren: Termine buchen, Tabellen aktualisieren, CI/CD-Pipelines auslösen oder Nachrichten senden.

Hier ist ein Grundgerüst für ein HTTP-basiertes Werkzeug:

import requests
from langchain_core.tools import tool

@tool
def fetch_article_snippet(url: str) -> str:
    """Fetch a plain-text snippet from a given URL."""
    response = requests.get(url, timeout=10)
    response.raise_for_status()
    return response.text[:500]

Ersetze die Werkzeuge `multiply` und `add` im Agentenskript durch `fetch_article_snippet`, und der Agent kann unter deinen Anweisungen im Web surfen.

---

Wann du welchen Ansatz verwendest

Generative KI ist effizient, wenn das Ergebnis der Inhalt selbst ist. Verwende sie für Entwürfe, Zusammenfassungen, Übersetzungen, Codevervollständigung und kreatives Schreiben. Sie ist schnell, günstig und vorhersehbar. Die Last, die Ausgabe in einen größeren Prozess zu integrieren, bleibt bei dir.

Agentische KI glänzt, wenn das Ergebnis eine abgeschlossene Aufgabe ist. Verwende sie, wenn die Arbeit mehrere Schritte, externe Datenquellen oder Entscheidungspunkte umfasst. Typische Kandidaten sind:

• Rechercheassistenten, die Informationen von mehreren Seiten sammeln und synthetisieren.
• Softwareentwicklungs-Agenten, die ein Repository lesen, Dateien bearbeiten und Tests ausführen.
• Ops-Agenten, die Logs überwachen, Anomalien erkennen und Abhilfemaßnahmen auslösen.
• Persönliche Assistenten, die Kalender, E-Mails und Erinnerungen verwalten.

Die Kosten agentischer Systeme liegen in der höheren Komplexität. Du musst eine Werkzeugschnittstelle definieren, Fehler behandeln, Schleifeniterationen begrenzen, um wildes Verhalten zu verhindern, und Schutzmaßnahmen für Aktionen mit nicht umkehrbaren Nebenwirkungen einbauen. Ein reiner generativer Aufruf schreibt Text; ein Agent könnte eine Datenbankzeile löschen, wenn du es zulässt. Füge entsprechende Berechtigungen und Checkpoints mit Mensch-im-Loop hinzu.

Wie sowohl die allgemeine Produktentwicklung von OpenAI als auch der Microsoft AI Blog betont haben, bewegt sich die Branche in Richtung Systeme, in denen Modelle in Arbeitsabläufe eingebettet sind, statt als isolierte Chat-Endpunkte zu dienen. Die Entwicklerressourcen von NVIDIA beschreiben dasselbe Muster: Modelle handeln zunehmend im Auftrag von Nutzern und operieren mit eigener Argumentation und eigenem Werkzeugabruf in verschiedenen Umgebungen. Die Infrastruktur reift noch, aber die Richtung ist klar.

---

Der Blick nach vorn

Die Grenze zwischen generativer und agentischer KI ist keine Mauer. Moderne Agenten bauen auf generativen Modellen auf, und generative Modelle werden oft als Komponenten innerhalb von Agenten verwendet. Der praktische Wandel liegt in der Schwerpunktsetzung des Designs:

• **Generative KI optimiert die Qualität des ausgegebenen Tokenstroms.**
• **Agentische KI optimiert den Erfolg der gesamten Aufgabenausführung.**

Ein agentisches System behandelt jede Textausgabe als Zwischenschritt. Es fragt: „Was soll ich als Nächstes tun, angesichts dieses Ergebnisses?" Die Argumentation des Modells ist der Orchestrator; Werkzeuge sind seine Hände; Beobachtung sind seine Augen; und deine Anweisungen definieren die Mission.

Für Entwickler ist die unmittelbare Erkenntnis pragmatisch. Wenn du derzeit ein LLM verwendest, um Code zu generieren, stelle dir die Frage, ob das Modell einfach Code ausgeben oder ihn tatsächlich gegen eine Testsuite ausführen, die Fehlermeldungen lesen und iterieren sollte, bis die Tests bestehen. Wenn du ein LLM zum Entwerfen von Statusberichten verwendest, überlege, ob es auch die Daten sammeln, das Diagramm erstellen und die E-Mail senden sollte.

Die Beispiele in diesem Artikel sind bewusst klein, aber sie zeigen den zweistufigen kognitiven Prozess, der einen Chatbot von einem Agenten unterscheidet: *entscheide, was aufgerufen werden soll*, und *rufe es dann auf*. Sobald du anspruchsvollere Werkzeuge, Speicher und abgesicherte Ausführungsrichtlinien hinzufügst, skaliert dieselbe Struktur auf reale operative Aufgaben.

Beginne mit der Generierung. Umhülle sie dann mit Handlung. Das ist der kürzeste Weg von der Inhaltserstellung zum autonomen Handeln.

---

Fazit

Generative KI und agentische KI repräsentieren zwei Stufen derselben Technologie. Die erste erzeugt anspruchsvolle Inhalte als Reaktion auf eine Eingabeaufforderung. Die zweite verwandelt Eingabeaufforderungen in Projekte, Projekte in Pläne und Pläne in ausgeführte Aktionen. Indem du eine Python-Umgebung eingerichtet, das OpenAI-SDK und LangChain installiert und die beiden obigen Beispiele durchgegangen bist, hast du beide Paradigmen in ihrer grundlegendsten Form gesehen: einen einzelnen Modellaufruf und eine mehrstufige Schleife mit Werkzeugnutzung.

Die produktivsten Systeme der kommenden Jahre werden wahrscheinlich beide Ansätze kombinieren – generative Modelle für ihre Sprachgewandtheit und Kreativität nutzen und ihnen agentische Architekturen zugrunde legen, die planen, handeln und sich anpassen. Egal, womit du beginnst, das Ziel ist dasselbe: Die Maschine von einem Generator von Worten zu einem Partner zu machen, der Dinge erledigt.