Agentic KI vs. Generative KI: Den Wandel von der Kreation zur Aktion verstehen

Agentic KI vs. Generative KI: Vom Erstellen zum Handeln – ein Paradigmenwechsel

Die Landschaft der künstlichen Intelligenz durchläuft einen tiefgreifenden Wandel. In den letzten zwei Jahren wurde die Diskussion von **generativer KI** dominiert – Modellen, die Texte, Bilder, Code und Musik aus einfachen Eingabeaufforderungen erzeugen. Doch ein neues Paradigma zeichnet sich ab: **agentische KI** – Systeme, die nicht nur Inhalte generieren, sondern auch darauf basierend handeln, Entscheidungen treffen, mehrschrittige Arbeitsabläufe ausführen und mit der Welt interagieren.

Dieser Artikel untersucht die grundlegenden Unterschiede zwischen generativer und agentischer KI, warum dieser Wandel von Bedeutung ist und wie Sie noch heute mit konkreten, praxisnahen Beispielen eigene agentische Systeme aufbauen können.

Was ist generative KI?

Generative KI bezeichnet Modelle, die auf der Grundlage von Mustern aus riesigen Datensätzen neue Inhalte erstellen. Diese Modelle – wie GPT-4, DALL·E und Claude – zeichnen sich aus durch:

• **Textgenerierung**: Verfassen von Artikeln, Code, Gedichten oder Zusammenfassungen.
• **Bilderstellung**: Erzeugen von Bildern aus Textbeschreibungen.
• **Audiosynthese**: Generieren von Musik oder Sprache.
• **Datenerweiterung**: Erstellen synthetischer Datensätze.

Generative KI ist **reaktiv**: Sie reagiert auf eine Eingabeaufforderung und liefert ein Ergebnis. Sie plant nicht von sich aus, denkt nicht über langfristige Ziele nach und interagiert nicht mit externen Systemen. Das Ergebnis ist das Ende des Prozesses.

Was ist agentische KI?

Agentische KI stellt einen Schritt über die reine Generierung hinaus dar. Ein KI-Agent ist ein System, das:

• **seine Umgebung wahrnimmt** (über APIs, Datenbanken, Sensoren oder Benutzereingaben).
• **über Ziele und Teilaufgaben nachdenkt**.
• **handelt**, indem es Befehle ausführt, Werkzeuge aufruft oder den Systemzustand ändert.
• **aus Rückmeldungen lernt**, um zukünftige Aktionen zu verbessern.

Agenten können ein komplexes Ziel wie „Plane einen Teamausflug nach San Francisco" in Teilaufgaben zerlegen: Veranstaltungsorte suchen, Verfügbarkeit prüfen, Preise vergleichen, Flüge buchen und Kalendereinladungen versenden. Jeder Schritt beinhaltet Entscheidungen und Interaktionen mit externen Systemen.

Der entscheidende Unterschied: **Generative KI erstellt; agentische KI führt aus.**

Die wichtigsten Unterschiede auf einen Blick

| Dimension | Generative KI | Agentische KI | |-----------|---------------|---------------| | **Primäre Ausgabe** | Inhalt (Text, Bild, Code) | Aktionen (API-Aufrufe, Dateioperationen, Entscheidungen) | | **Interaktionsstil** | Einzelschritt (Eingabe → Antwort) | Mehrschrittige, zielorientierte Schleifen | | **Zustandsverwaltung** | Zustandslos (meistens) | Zustandsbehaftet (verfolgt Fortschritt, Gedächtnis) | | **Werkzeugnutzung** | Selten (außer bei einigen eingabeaufforderungsbasierten Tools) | Kernfähigkeit (ruft externe APIs, Datenbanken auf) | | **Fehlerbehebung** | Eingeschränkt (generiert Ausgabe neu) | Proaktiv (wiederholt, passt Strategie an) | | **Autonomiegrad** | Niedrig (Mensch im Kreislauf typisch) | Mittel bis hoch (kann eigenständig arbeiten) |

Warum der Wandel wichtig ist

Der Übergang von generativer zu agentischer KI wird durch praktische Bedürfnisse vorangetrieben:

• **Automatisierung**: Unternehmen möchten KI, die nicht nur eine E-Mail entwirft, sondern sie auch versendet, Nachfassaktionen plant und CRM-Datensätze aktualisiert.
• **Komplexe Arbeitsabläufe**: Aufgaben wie „Einen Cloud-Server bereitstellen und eine Firewall konfigurieren" erfordern mehrere Schritte, bedingte Logik und Fehlerbehandlung – weit über das hinaus, was ein einzelner generativer Aufruf leisten kann.
• **Zuverlässigkeit**: Agenten können Ausgaben überprüfen, fehlgeschlagene Vorgänge wiederholen und Probleme eskalieren lassen, wodurch die Notwendigkeit ständiger menschlicher Aufsicht reduziert wird.

Der Microsoft AI Blog hat hervorgehoben, wie Agenten in Produktivitätstools integriert werden, während Anthropic News die Sicherheitsimplikationen der Gewährung von mehr Autonomie für Modelle diskutiert hat. Der NVIDIA AI Blog hat die Infrastruktur behandelt, die für den Betrieb agentischer Systeme in großem Maßstab erforderlich ist.

Voraussetzungen für den Aufbau eines agentischen Systems

Um die folgenden Beispiele nachvollziehen zu können, benötigen Sie:

• **Python 3.9+**, installiert auf Ihrem System.
• Einen **Code-Editor** (VS Code empfohlen).
• Einen **OpenAI-API-Schlüssel** (oder Zugang zu einem beliebigen LLM-Anbieter mit Unterstützung für Funktionsaufrufe).
• Grundlegende Vertrautheit mit **Kommandozeilen-Schnittstellen** und **Python-Virtual Environments**.

Wir werden einen einfachen Agenten bauen, der basierend auf einem Benutzerziel Dateioperationen und Websuchen durchführen kann.

Schritt-für-Schritt-Installation

1. Richten Sie eine Python-Virtual Environment ein

Isolieren Sie Abhängigkeiten, um Konflikte mit anderen Projekten zu vermeiden.

python -m venv agent-env
source agent-env/bin/activate  # Unter Windows: agent-env\Scripts\activate

2. Installieren Sie die erforderlichen Pakete

Wir verwenden die `openai`-Bibliothek für den LLM-Zugriff und `requests` für HTTP-Aufrufe.

pip install openai requests python-dotenv

• `openai`: Offizieller Python-Client für die OpenAI-API.
• `requests`: Zum Tätigen von HTTP-Anfragen an externe Dienste.
• `python-dotenv`: Lädt Umgebungsvariablen aus einer `.env`-Datei.

3. Erstellen Sie eine `.env`-Datei für Ihren API-Schlüssel

Speichern Sie sensible Anmeldeinformationen sicher.

echo "OPENAI_API_KEY=your_key_here" > .env

Ersetzen Sie `your_key_here` durch Ihren tatsächlichen OpenAI-API-Schlüssel. Übergeben Sie diese Datei niemals an die Versionskontrolle.

4. Schreiben Sie das Kernskript für den Agenten

Erstellen Sie eine Datei namens `agent.py` mit der folgenden Struktur:

import os
import json
import requests
from openai import OpenAI
from dotenv import load_dotenv

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

# Definieren Sie die Werkzeuge, die der Agent verwenden kann
tools = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Liest den Inhalt einer Textdatei",
            "parameters": {
                "type": "object",
                "properties": {
                    "filepath": {"type": "string", "description": "Pfad zur Datei"}
                },
                "required": ["filepath"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "Schreibt Inhalt in eine Textdatei",
            "parameters": {
                "type": "object",
                "properties": {
                    "filepath": {"type": "string", "description": "Pfad zur Datei"},
                    "content": {"type": "string", "description": "Zu schreibender Inhalt"}
                },
                "required": ["filepath", "content"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Durchsucht das Web nach Informationen",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Suchanfrage"}
                },
                "required": ["query"]
            }
        }
    }
]

# Implementierungen der Werkzeuge
def read_file(filepath):
    with open(filepath, 'r') as f:
        return f.read()

def write_file(filepath, content):
    with open(filepath, 'w') as f:
        f.write(content)
    return f"Geschrieben nach {filepath}"

def web_search(query):
    # Vereinfachte Suche mit DuckDuckGo (kein API-Schlüssel erforderlich)
    url = f"https://api.duckduckgo.com/?q={query}&format=json&no_html=1"
    response = requests.get(url)
    data = response.json()
    # Text aus den ersten Ergebnissen extrahieren
    results = data.get("AbstractText", "") or data.get("RelatedTopics", [{}])[0].get("Text", "Keine Ergebnisse gefunden")
    return results[:500]  # Aus Gründen der Kürze abschneiden

# Agenten-Schleife
def run_agent(user_goal):
    messages = [{"role": "user", "content": user_goal}]
    
    while True:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )
        
        message = response.choices[0].message
        messages.append(message)
        
        if message.tool_calls:
            for tool_call in message.tool_calls:
                func_name = tool_call.function.name
                func_args = json.loads(tool_call.function.arguments)
                
                if func_name == "read_file":
                    result = read_file(**func_args)
                elif func_name == "write_file":
                    result = write_file(**func_args)
                elif func_name == "web_search":
                    result = web_search(**func_args)
                else:
                    result = f"Unbekannte Funktion: {func_name}"
                
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": str(result)
                })
        else:
            # Keine Werkzeugaufrufe → endgültige Antwort
            return message.content

# Beispielverwendung
if __name__ == "__main__":
    goal = input("Geben Sie Ihr Ziel ein: ")
    result = run_agent(goal)
    print("\nAntwort des Agenten:\n", result)

Dieses Skript definiert drei Werkzeuge (`read_file`, `write_file`, `web_search`) und eine Schleife, die es dem LLM ermöglicht, zu entscheiden, welche Werkzeuge aufgerufen werden sollen, Ergebnisse zu interpretieren und fortzufahren, bis es eine endgültige Antwort liefert.

Anwendungsbeispiele

Beispiel 1: Dateizusammenfassung

Führen Sie den Agenten aus und geben Sie ihm ein Ziel, das das Lesen einer Datei beinhaltet:

python agent.py

Geben Sie bei der Eingabeaufforderung Folgendes ein:

Lies die Datei notizen.txt, fasse sie zusammen und speichere die Zusammenfassung in zusammenfassung.txt

Der Agent wird: 1. `read_file("notizen.txt")` aufrufen, um den Inhalt zu erhalten. 2. Eine Zusammenfassung mit seinen eigenen Sprachfähigkeiten erstellen. 3. `write_file("zusammenfassung.txt", zusammenfassungsinhalt)` aufrufen, um sie zu speichern.

Beispiel 2: Recherche und Bericht

Geben Sie ein Ziel wie folgt ein:

Suche nach den neuesten Nachrichten über KI-Agenten im Jahr 2025 und schreibe dann einen kurzen Bericht in bericht.txt

Der Agent wird: 1. `web_search("KI-Agenten 2025 Nachrichten")` aufrufen, um Informationen zu beschaffen. 2. Einen Bericht auf der Grundlage der Suchergebnisse verfassen. 3. Den Bericht mit `write_file` speichern.

Beispiel 3: Mehrschrittiger Arbeitsablauf

Lies todo.txt, suche nach dem obersten Eintrag in dieser Liste und speichere die Suchergebnisse in recherche.txt

Dies zeigt, wie der Agent mehrere Werkzeugaufrufe miteinander verknüpft: zuerst eine Datei lesen, dann deren Inhalt als Suchanfrage verwenden und schließlich die Ausgabe schreiben.

Wie sich agentische KI in der Praxis unterscheidet

Aus Entwicklersicht verändert der Wechsel von generativer zu agentischer KI die Art und Weise, wie Sie Systeme entwerfen:

• **Generative KI**: Sie rufen eine API einmal auf, erhalten eine Antwort und präsentieren sie dem Benutzer. Das Modell behält keinen Zustand bei und erinnert sich nicht an vorherige Interaktionen.
• **Agentische KI**: Sie implementieren eine Schleife, die Nachrichten hin und her sendet, einen Verlauf von Werkzeugaufrufen und Ergebnissen führt und es dem Modell ermöglicht, darüber nachzudenken, was als Nächstes zu tun ist.

Die Agentenschleife in unserem Beispiel ist eine vereinfachte Version des **ReAct**-Musters (Reasoning + Acting), das in Produktionssystemen weit verbreitet ist. Fortgeschrittenere Frameworks wie LangChain, AutoGPT oder Microsofts Semantic Kernel bauen auf diesem Muster auf und bieten zusätzliche Funktionen wie Gedächtnis, Planung und Fehlerbehebung.

Herausforderungen und Überlegungen

Zuverlässigkeit

Agenten können Fehler machen, z. B. das falsche Werkzeug aufrufen oder Ergebnisse falsch interpretieren. Robuste Fehlerbehandlung und Validierung durch einen Menschen im Kreislauf sind entscheidend.

Latenz

Mehrschrittiges Denken braucht Zeit. Jeder Werkzeugaufruf fügt Netzwerk-Roundtrips und LLM-Inferenzzeit hinzu. Die Optimierung auf Geschwindigkeit erfordert sorgfältiges Design.

Sicherheit

Wie Anthropic News festgestellt hat, birgt die Gewährung von Autonomie für Modelle Risiken. Agenten könnten unbeabsichtigte Aktionen ausführen (z. B. Dateien löschen oder unbefugte API-Aufrufe tätigen). Sperren Sie Agentenberechtigungen immer in einer Sandbox und validieren Sie Werkzeugaufrufe.

Kosten

Jeder Schritt in einer Agentenschleife verbraucht Tokens. Ein einziges Ziel kann 5–10 LLM-Aufrufe auslösen, was die Kosten im Vergleich zu einer einzelnen generativen Abfrage erhöht.

Die Zukunft: Von Werkzeugen zu autonomen Systemen

Die Entwicklung ist klar: Generative KI wird zu einer Komponente innerhalb größerer agentischer Systeme. Anstatt „Schreib mir ein Gedicht" zu sagen, werden Benutzer sagen: „Plane die Geburtstagsfeier meiner Tochter – verschicke Einladungen, bestelle Kuchen, buche einen Veranstaltungsort und lege Erinnerungen an."

Unternehmen wie OpenAI, Microsoft und Anthropic investieren stark in die Agenteninfrastruktur. Der NVIDIA AI Blog hat erörtert, wie GPU-beschleunigte Inferenz es Agenten ermöglicht, komplexe Denkaufgaben schneller auszuführen, während der Microsoft AI Blog Agenten gezeigt hat, die in Office 365 und Azure integriert sind.

Fazit

Generative KI hat die Fähigkeit freigesetzt, Inhalte in großem Maßstab zu erstellen. Agentische KI baut auf dieser Grundlage auf, indem sie Systeme befähigt, zu handeln – zu planen, auszuführen und sich anzupassen, um reale Ziele zu erreichen.

Der Wandel vom Erstellen zum Handeln ist nicht nur eine technische Weiterentwicklung; es ist eine Veränderung in der Art und Weise, wie wir über die Rolle der KI denken. Generative KI ist ein Werkzeug, das Sie einsetzen. Agentische KI ist ein Mitarbeiter, der Dinge erledigt.

Fangen Sie klein an: Bauen Sie einen Agenten, der Dateien liest und schreibt. Fügen Sie eine Websuche hinzu. Erweitern Sie dann auf APIs, Datenbanken und Cloud-Dienste. Die Architektur ist dieselbe – eine Schleife aus Denken, Werkzeugnutzung und Iteration. Was sich ändert, ist die Komplexität der Ziele, die Sie erreichen können.

Das Zeitalter der agentischen KI hat begonnen. Die Frage ist nicht mehr „Was kann KI erstellen?", sondern „Was kann KI erreichen?"