Agentische KI vs. Generative KI: Der Wandel von statischen Ausgaben zu autonomem Handeln

Agentische KI vs. Generative KI: Der Wandel von statischen Ausgaben zu autonomem Handeln

Künstliche Intelligenz entwickelt sich rasant, und zwei Begriffe dominieren 2025 die Diskussion: **Generative KI** und **Agentische KI**. Beide haben Wurzeln im Deep Learning und in großen Sprachmodellen, unterscheiden sich jedoch grundlegend in ihrem Paradigma. Generative KI erzeugt Inhalte – Texte, Bilder, Code, Musik – basierend auf Aufforderungen. Agentische KI geht einen Schritt weiter: Sie handelt autonom, um ein Ziel zu erreichen, trifft Entscheidungen, nutzt Werkzeuge und passt sich wechselnden Umgebungen an. Dieser Wandel von statischen Ausgaben zu autonomem Handeln verändert alles – von der Softwareentwicklung bis hin zur Automatisierung von Geschäftsprozessen.

In diesem praktischen technischen Artikel klären wir den Unterschied und gehen dann ein konkretes Beispiel durch: den Bau eines einfachen agentischen Systems, das Websuchen durchführen, Webseiten lesen und Ergebnisse auf Basis eines übergeordneten Ziels zusammenfassen kann. Wir besprechen auch den zugrundeliegenden Technologie-Stack und wie Sie noch heute loslegen können.

Was ist Generative KI?

Generative KI bezeichnet Modelle, die auf der Grundlage von aus Trainingsdaten gelernten Mustern neue Inhalte erstellen. Bekannte Beispiele sind OpenAIs GPT‑4, Anthropics Claude und Bildgeneratoren wie DALL‑E. Diese Systeme sind reaktiv: Sie erhalten eine Eingabeaufforderung und liefern eine Vervollständigung. Auch wenn sie in komplexen Pipelines verkettet werden können, ist die Kerninteraktion zustandslos und auf einen Durchgang ausgelegt (oder mit Gedächtnis mehrschrittig, aber dennoch primär reaktiv).

Der NVIDIA AI Blog hat hervorgehoben, wie generative KI für alles von der Wirkstoffforschung bis zur Codegenerierung eingesetzt wird. Die Ausgabe des Modells ist statisch – einmal erzeugt, ändert sie sich nicht, es sei denn, die Eingabe wird wiederholt. Es gibt keine inhärente Fähigkeit, „es noch einmal zu versuchen“ oder „zusätzliche Daten zu holen“, es sei denn, diese Logik wird außerhalb des Modells explizit programmiert.

Was ist Agentische KI?

Agentische KI beschreibt Systeme, die eigenständig handeln, um ein Ziel zu erreichen. Ein Agent verfügt über einen Zustand, einen Plan, eine Reihe von Werkzeugen (wie Taschenrechner, Websuche, Dateisysteme) und einen Speicher, der über Aktionen hinweg bestehen bleibt. Er entscheidet über seine nächsten Schritte basierend auf seinen aktuellen Beobachtungen und dem Feedback früherer Aktionen.

Anthropics News-Seite hat Fortschritte bei den „Tool-Use“- und „Computer-Use“-Fähigkeiten ihrer Modelle dokumentiert, die es Claude ermöglichen, im Namen eines Benutzers zu handeln. Microsofts AI Blog hat über AutoGen berichtet, ein Framework für die Erstellung von Multi-Agenten-Gesprächen. OpenAIs News hat ChatGPT-Plugins vorgestellt, die das Modell in einen Agenten verwandeln, der in Echtzeit Daten abrufen und Aktionen wie das Buchen von Flügen durchführen kann.

Der entscheidende Unterschied: **Generative KI endet mit der Ausgabe; Agentische KI beginnt mit der Ausgabe und handelt weiter, bis ein Ziel erreicht ist.**

Warum der Wandel wichtig ist

Generative KI eignet sich hervorragend für einmalige Erstellungsaufgaben, versagt jedoch, wenn die Aufgabe mehrschrittiges Denken, externe Werkzeuge oder Anpassung erfordert. Beispielsweise ist „Schreibe einen Blogbeitrag über Quantencomputing“ eine generative Aufgabe. „Recherchiere die neuesten Quantencomputing-Startups, erstelle eine Liste ihrer Finanzierungsrunden, schreibe eine 1000-Wörter-Zusammenfassung und sende sie per E-Mail an mein Team“ ist eine agentische Aufgabe. Letzteres erfordert, dass die KI das Web durchsucht, Ergebnisse analysiert, entscheidet, welche Quellen glaubwürdig sind, einen Text verfasst und dann eine E-Mail sendet – alles ohne manuelles Eingreifen bei jedem Schritt.

Dieser Wandel hat enorme Auswirkungen auf die Produktivität. Anstatt ein Modell wiederholt aufzufordern, geben Sie ihm ein Ziel und lassen es die Arbeit orchestrieren.

Voraussetzungen für den Bau eines agentischen Systems

Bevor wir in den Code eintauchen, listen wir auf, was wir benötigen:

• Python 3.10+
• Einen OpenAI-API-Schlüssel (oder Anthropic, oder jedes LLM mit Tool-Use-Unterstützung)
• `requests`-Bibliothek für HTTP-Aufrufe
• `beautifulsoup4` für HTML-Parsing
• `python-dotenv` zur Verwaltung von API-Schlüsseln
• Einen modernen Texteditor oder eine IDE

Wir bauen einen minimalen Recherche-Agenten, der: 1. Eine Recherchefrage annimmt. 2. Das Web mit einer kostenlosen API durchsucht (DuckDuckGo über die `duckduckgo_search`-Bibliothek). 3. Den Inhalt des obersten Ergebnisses liest. 4. Diesen mit GPT‑4o zusammenfasst. 5. Optional den Zyklus wiederholt, um die Antwort zu verfeinern.

Diese autonome Schleife ist die Essenz agentischer KI.

Schritt-für-Schritt-Installation

Richten Sie zunächst eine virtuelle Umgebung ein und installieren Sie die Abhängigkeiten. Öffnen Sie Ihr Terminal.

# Erstellen Sie ein Projektverzeichnis
mkdir agent-demo
cd agent-demo

# Erstellen Sie eine Python-Virtual-Umgebung
python3 -m venv venv

# Aktivieren Sie diese (Linux/macOS)
source venv/bin/activate

# Unter Windows: venv\Scripts\activate

Installieren Sie nun die benötigten Pakete. Wir verwenden `openai` für den GPT-Zugriff, `duckduckgo_search` für die Websuche und `requests`/`beautifulsoup4` zum Scraping.

# Kernpakete installieren
pip install openai duckduckgo_search requests beautifulsoup4 python-dotenv

Erstellen Sie eine Datei namens `.env` im Projektstamm und fügen Sie Ihren OpenAI-Schlüssel hinzu:

OPENAI_API_KEY=sk-ihr-schluessel-hier

Anwendungsbeispiel: Ein einfacher Recherche-Agent

Wir schreiben den Agenten in eine einzelne Python-Datei `agent.py`. Der Agent wird drei Hauptfunktionen haben: `search_web`, `fetch_page` und `ask_llm`. Die Hauptschleife entscheidet, ob erneut gesucht oder eine endgültige Antwort erstellt wird.

Beginnen Sie mit dem Laden der Abhängigkeiten und des API-Schlüssels.

# agent.py
import os
from dotenv import load_dotenv
from openai import OpenAI
from duckduckgo_search import DDGS
import requests
from bs4 import BeautifulSoup

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

Definieren Sie eine Suchfunktion mit DuckDuckGo.

def search_web(query, max_results=3):
    """Durchsucht DuckDuckGo und gibt eine Liste von URLs zurück."""
    with DDGS() as ddgs:
        results = list(ddgs.text(query, max_results=max_results))
    urls = [r["href"] for r in results if "href" in r]
    return urls[:max_results]

Nun eine Funktion zum Extrahieren des Haupttextes einer URL.

def fetch_page(url):
    """Ruft eine Webseite ab und extrahiert den Text."""
    try:
        resp = requests.get(url, timeout=10)
        resp.raise_for_status()
        soup = BeautifulSoup(resp.text, "html.parser")
        # Entferne Skript-/Style-Elemente
        for tag in soup(["script", "style"]):
            tag.decompose()
        text = soup.get_text(separator="\n", strip=True)
        # Kürzen, um Token-Limits zu vermeiden
        return text[:3000]
    except Exception as e:
        return f"Fehler beim Abrufen von {url}: {e}"

Wir brauchen eine Funktion, um das LLM zu befragen und seine Antwort zu parsen. Die Magie der agentischen KI liegt darin, wie wir die Eingabeaufforderung strukturieren: Wir teilen dem Modell mit, welche Aktionen es ausführen kann (suchen, lesen, beenden) und lassen es entscheiden.

Wir verwenden OpenAIs Funktionsaufruf (Tool-Use), damit das Modell strukturierte Aktionen ausgeben kann. Der Einfachheit halber verwenden wir jedoch eine textbasierte Schleife, bei der das Modell entweder eine endgültige Antwort oder einen Befehl „SEARCH: <query>“ zurückgibt.

def ask_llm(messages):
    """Sendet eine Konversation an GPT-4o und gibt die Antwort zurück."""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        temperature=0.3
    )
    return response.choices[0].message.content

Nun die Hauptschleife des Agenten.

def run_agent(goal, max_iterations=5):
    """Autonomer Agent: Suche, Lesen, Zusammenfassen, bis das Ziel erreicht ist."""
    system_prompt = (
        "Du bist ein Recherche-Agent. Du hast Zugriff auf Websuche und das Lesen von Webseiten. "
        "Zum Suchen antworte mit 'SEARCH: <deine Suchanfrage>'. "
        "Zum Lesen einer Seite antworte mit 'READ: <URL>'. "
        "Wenn du genug Informationen hast, antworte mit 'FINAL: <deine Antwort>'. "
        "Sei prägnant. Verwende nur Informationen, die du abgerufen hast."
    )
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": goal}
    ]

    for i in range(max_iterations):
        print(f"\n--- Iteration {i+1} ---")
        response = ask_llm(messages)
        print(f"Agent sagt: {response[:100]}...")

        if response.startswith("FINAL:"):
            return response[6:].strip()
        elif response.startswith("SEARCH:"):
            query = response[7:].strip()
            print(f"Suche nach: {query}")
            urls = search_web(query)
            # URLs an das Modell zurückgeben
            messages.append({"role": "assistant", "content": response})
            messages.append({"role": "user", "content": f"Diese URLs wurden gefunden: {urls}. Wähle eine zum Lesen aus."})
        elif response.startswith("READ:"):
            url = response[5:].strip()
            print(f"Lese: {url}")
            page_text = fetch_page(url)
            messages.append({"role": "assistant", "content": response})
            messages.append({"role": "user", "content": f"Seiteninhalt (gekürzt):\n{page_text}\nWas schlussfolgerst du?"})
        else:
            # Fallback: als endgültige Antwort behandeln
            return response

    return "Ziel nicht innerhalb der Iterationsgrenze erreicht."

Führen Sie abschließend den Agenten mit einem Beispielziel aus.

if __name__ == "__main__":
    goal = "Was sind die neuesten Fortschritte in der agentischen KI laut OpenAI und Anthropic?"
    answer = run_agent(goal)
    print("\n===== ENDGÜLTIGE ANTWORT =====")
    print(answer)

Führen Sie das Skript aus:

python agent.py

Sie sollten sehen, wie der Agent DuckDuckGo durchsucht, eine Seite über Anthropics Tool-Use-Fähigkeiten liest und eine Zusammenfassung erstellt. Diese Schleife zeigt, wie ein generatives Modell in eine autonome Entscheidungsarchitektur eingebettet wird.

Praktische Überlegungen

Werkzeugauswahl

Für produktive agentische Systeme benötigen Sie möglicherweise robustere Werkzeuge:

• **Websuche**: SerpAPI, Bing Search API
• **Web Scraping**: Verwenden Sie strukturierte APIs (z. B. NewsAPI) anstelle von rohem HTML, um Sperren zu vermeiden.
• **Speicher**: Speichern Sie Kontext in einer Vektordatenbank wie Chroma oder Pinecone.
• **Planung**: Verwenden Sie einen „ReAct“-Prompt-Stil oder Frameworks wie LangChain, AutoGen oder CrewAI.

Kosten und Latenz

Agentische Schleifen können viele LLM-Aufrufe verursachen. Jede Iteration kostet Tokens für Eingabe und Ausgabe. Beachten Sie das Kontextfenster. Verwenden Sie kleinere Modelle (z. B. GPT‑4o-mini) für Routineaktionen und reservieren Sie große Modelle für die endgültige Synthese.

Sicherheit und Leitplanken

Einem Agenten Autonomie zu gewähren, birgt Risiken. Implementieren Sie immer:

• **Human-in-the-Loop** für destruktive Aktionen.
• **Ratenbegrenzung**, um außer Kontrolle geratene Aufrufe zu vermeiden.
• **Eingabevalidierung**, um Prompt-Injection über abgerufene Inhalte zu verhindern.

Fazit

Generative KI gab uns eine leistungsstarke Content-Erstellungsmaschine. Agentische KI fügt das Lenkrad hinzu, sodass die Maschine selbstständig zu einem Ziel navigieren kann. Der Wandel von statischen Ausgaben zu autonomem Handeln ist nicht nur inkrementell – es ist ein Paradigmenwechsel. Statt ein Modell zu bitten „Schreibe einen Blogbeitrag“, können Sie es jetzt bitten: „Schreibe einen Blogbeitrag, nachdem du das Thema recherchiert, Fakten geprüft und gemäß meinem Styleguide formatiert hast.“

Während der NVIDIA AI Blog, OpenAI News, Microsoft AI Blog und Anthropic News die Fähigkeiten weiter vorantreiben, werden die Werkzeuge zum Bau eigener Agenten immer zugänglicher. Der einfache Agent, den wir hier gebaut haben, ist ein Grundgerüst – Sie können ihn mit APIs, Datenbanken und Entscheidungsbäumen erweitern, um ganze Workflows zu automatisieren.

Die Zukunft der KI liegt nicht nur in der Generierung von Inhalten; es geht darum, Systeme zu schaffen, die in unserem Namen handeln, aus ihrer Umgebung lernen und komplexe Aufgaben ohne ständige menschliche Aufsicht erledigen. Das ist der wahre Wandel: von Ausgaben zu Handlungen.