Agentische KI vs. Generative KI: Autonomie und Kreation vereinen

KI-Agent vs. generative KI: Autonomie mit Kreativität verbinden

Die Diskussion über künstliche Intelligenz hat sich in zwei dominante Paradigmen gespalten: **generative KI**, die neue Inhalte erzeugt – Texte, Bilder, Code, Musik – und **agentische KI**, die autonom handelt, um Ziele zu erreichen, mit Werkzeugen interagiert und Entscheidungen trifft. Obwohl sie oft als konkurrierende Ansätze dargestellt werden, werden die leistungsfähigsten Systeme des nächsten Jahrzehnts beide Ansätze verbinden: Agenten, die nicht nur erschaffen, sondern auch auf der Grundlage ihrer Kreationen handeln.

In diesem Artikel untersuchen wir die Unterschiede, erkunden, wie sie sich ergänzen, und gehen eine konkrete Implementierung durch, die ein generatives Sprachmodell mit einem autonomen Agenten-Framework kombiniert. Am Ende haben Sie einen funktionierenden Prototypen, der eine Antwort generieren und dann eine Aktion ausführen kann – eine E-Mail senden oder eine Datei aktualisieren – basierend auf der Generierung.

Die Paradigmen verstehen

Generative KI: Der Schöpfer

Generative KI-Modelle – wie GPT-4, Claude, DALL·E oder Stable Diffusion – werden darauf trainiert, neuartige Ausgaben vorherzusagen und zu erzeugen. Sie zeichnen sich durch die **Erstellung von Inhalten** aus, sind aber im Grunde reaktiv: Sie reagieren auf Eingabeaufforderungen und benötigen für jede sinnvolle Interaktion einen Menschen im Kreislauf.

Quellen der **OpenAI News**-Seite und der **Anthropic News**-Seite betonen, dass diese Modelle immer leistungsfähiger, sicherer und besser auf die menschlichen Absichten abgestimmt werden. Doch ohne Orchestrierung kann ein generatives Modell keinen Flug buchen, keine Folge-E-Mail senden oder eine Aufgabe bis zur Erledigung wiederholen.

Agentische KI: Der Handelnde

Agentische KI bezieht sich auf Systeme, die ihre Umgebung wahrnehmen, Unterziele setzen, Werkzeuge (APIs, Dateisysteme, Browser) nutzen und ohne ständige menschliche Führung handeln können. Der **Microsoft AI Blog** und der **NVIDIA AI Blog** haben darüber diskutiert, wie Agenten entwickelt werden, um Workflows zu automatisieren, komplexe Simulationen zu verwalten und sogar Hardware zu entwerfen.

Ein Agent könnte entscheiden: „Ich muss das Wetter überprüfen, dann, wenn es sonnig ist, ein Bild von einem Picknick generieren und es über eine Social-Media-API posten.“ Das entscheidende Merkmal ist die **Autonomie des Handelns**.

Die Lücke und die Chance

Generative KI ohne Handlungsfähigkeit ist ein brillantes, aber passives Werkzeug. Agentische KI ohne generative Erstellung ist auf regelbasierte oder vordefinierte Verhaltensweisen beschränkt. Die Kombination beider ergibt ein System, das **einen Plan erstellen und ausführen** kann – einen Bericht schreiben und ihn per E-Mail versenden, eine Grafik entwerfen und sie skalieren, Code schreiben und ausführen.

Voraussetzungen

Um den praktischen Teil dieses Artikels nachvollziehen zu können, benötigen Sie:

• **Python 3.10 oder neuer**, installiert auf Ihrem System (Linux/macOS/WSL empfohlen).
• **pip** (Python-Paketmanager), aktualisiert auf die neueste Version.
• Einen **OpenAI-API-Schlüssel** (oder Zugang zu einer beliebigen LLM-API; wir verwenden OpenAI als Beispiel).
• Grundlegende Vertrautheit mit der Kommandozeile und Dateioperationen.

Wir werden einen einfachen Agenten bauen, der: 1. Ein übergeordnetes Ziel annimmt (z.B. „Schreibe eine Dankesnotiz an Alice und speichere sie als Datei“). 2. Ein generatives Modell verwendet, um die Notiz zu entwerfen. 3. Die Aktion (das Schreiben der Datei) autonom ausführt.

Schritt-für-Schritt-Installation

1. Virtuelle Umgebung erstellen und aktivieren

Die Isolierung von Abhängigkeiten verhindert Konflikte mit anderen Python-Projekten.

python3 -m venv agentic-venv
source agentic-venv/bin/activate   # Unter Windows: agentic-venv\Scripts\activate

2. Erforderliche Pakete installieren

Wir benötigen die Bibliothek `openai` für das generative Modell und `requests` für etwaige HTTP-Aufrufe.

pip install --upgrade openai requests

3. API-Schlüssel setzen

Speichern Sie Ihren API-Schlüssel als Umgebungsvariable. So bleibt er außerhalb des Quellcodes.

export OPENAI_API_KEY="sk-ihr-schlüssel-hier"

Für eine dauerhafte Einrichtung fügen Sie die obige Zeile Ihrer `~/.bashrc` oder `~/.zshrc` hinzu.

4. Installation überprüfen

Führen Sie ein kurzes Python-Skript aus, um die Verbindung zur OpenAI-API zu testen.

import openai
import os

openai.api_key = os.getenv("OPENAI_API_KEY")

response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Say 'hello world' in one word."}]
)

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

python test_openai.py

Erwartete Ausgabe: `hello` (oder ähnlich). Wenn Sie einen Fehler sehen, überprüfen Sie Ihren API-Schlüssel und Ihre Internetverbindung.

Anwendungsbeispiele: Generative und agentische Fähigkeiten kombinieren

Beispiel 1: Ein generativer Agent, der eine Notiz schreibt und speichert

Wir erstellen einen Agenten, der GPT‑4 verwendet, um eine höfliche Dankesnotiz zu generieren und diese dann automatisch in eine Datei schreibt.

**Erstellen Sie eine Datei `agentic_note.py`**:

import openai
import os

openai.api_key = os.getenv("OPENAI_API_KEY")

def generate_note(recipient: str, reason: str) -> str:
    """Generative KI nutzen, um eine Dankesnotiz zu entwerfen."""
    prompt = f"Write a short, warm thank-you note to {recipient} for {reason}."
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7
    )
    return response.choices[0].message.content

def save_note_to_file(content: str, filename: str = "note.txt") -> None:
    """Agentische Aktion: Inhalt in eine Datei schreiben."""
    with open(filename, "w") as f:
        f.write(content)
    print(f"Note saved to {filename}")

if __name__ == "__main__":
    recipient = input("Enter recipient name: ")
    reason = input("Enter reason for thanks: ")

    note_text = generate_note(recipient, reason)
    print("\nGenerated note:\n", note_text)

    save_note_to_file(note_text)

**Führen Sie den Agenten aus**:

python agentic_note.py

Geben Sie „Alice“ und „helping with the project“ ein. Der Agent generiert eine Notiz und schreibt sie ohne weitere Eingabe in `note.txt`. Das ist eine minimale Kombination: Das generative Modell erstellt, die agentische Logik führt aus.

Beispiel 2: Ein mehrstufiger Agent, der E-Mails generiert und sendet

Jetzt erweitern wir das Konzept: Der Agent generiert einen Betreff und einen Text und ruft dann eine E-Mail-Sende-API auf (wir simulieren dies mit einer Platzhalterfunktion, aber Sie können sie durch echten SMTP- oder SendGrid-Code ersetzen).

**Erstellen Sie `agentic_email.py`**:

import openai
import os

openai.api_key = os.getenv("OPENAI_API_KEY")

def generate_email_content(goal: str) -> dict:
    """GPT bitten, Betreff und Text einer E-Mail zu erstellen."""
    system_prompt = "You are a helpful assistant. Return a JSON with keys 'subject' and 'body'."
    user_prompt = f"Write a professional email with the following goal: {goal}"
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt}
        ],
        response_format={"type": "json_object"}
    )
    import json
    return json.loads(response.choices[0].message.content)

def send_email(to: str, subject: str, body: str) -> bool:
    """E-Mail-Versand simulieren. Durch echten SMTP-Code ersetzen."""
    print(f"Simulating sending email to {to}")
    print(f"Subject: {subject}")
    print(f"Body:\n{body}")
    return True

if __name__ == "__main__":
    recipient = "boss@example.com"
    goal = "Request approval for next week's vacation"

    email_parts = generate_email_content(goal)
    send_email(recipient, email_parts["subject"], email_parts["body"])

**Führen Sie es aus**:

python agentic_email.py

Der Agent entscheidet autonom über Betreff und Text und „sendet“ die E-Mail. In der Produktion würden Sie `send_email` durch echte SMTP-Authentifizierung oder einen Transaktions-E-Mail-Anbieter ersetzen.

Beispiel 3: Eine vollständige Agentenschleife mit Werkzeugnutzung

Für ein fortgeschritteneres Beispiel können wir eine einfache Schleife bauen, die es dem Agenten erlaubt, basierend auf den Entscheidungen des generativen Modells externe Werkzeuge aufzurufen (z.B. eine Websuche oder das Lesen einer Datei). Dieses Muster wird in Frameworks wie LangChain und Auto‑GPT verwendet.

Im Folgenden eine minimale Implementierung mit einer `while`-Schleife. Das generative Modell entscheidet über den nächsten Schritt.

import openai
import os

openai.api_key = os.getenv("OPENAI_API_KEY")

def ask_agent(prompt: str) -> str:
    """Allgemeine Abfrage an das LLM."""
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

def search_web(query: str) -> str:
    """Platzhalter für Websuche. Durch eine echte API ersetzen."""
    return f"Simulated results for: {query}"

def write_file(filename: str, content: str) -> str:
    """Agentische Aktion: Inhalt in eine Datei schreiben."""
    with open(filename, "w") as f:
        f.write(content)
    return f"File {filename} written."

# Werkzeuge-Wörterbuch
tools = {
    "search": search_web,
    "write": write_file
}

if __name__ == "__main__":
    goal = "Find the current population of Tokyo and save it to a file."
    max_steps = 5
    step = 0

    user_prompt = (
        f"You are an autonomous agent. Your goal is: {goal}\n\n"
        "You have access to the following tools: search(query), write(filename, content).\n"
        "To use a tool, respond with exactly:\n"
        "TOOL: tool_name\n"
        "ARGS: arg1, arg2, ...\n\n"
        "If the goal is complete, respond with 'FINAL: <answer>'.\n\n"
        "What is your next action?"
    )

    while step < max_steps:
        step += 1
        response = ask_agent(user_prompt)

        if response.startswith("FINAL:"):
            print("Goal completed:", response[6:])
            break

        if response.startswith("TOOL:"):
            lines = response.strip().split("\n")
            tool_name = lines[0].replace("TOOL:", "").strip()
            args_str = lines[1].replace("ARGS:", "").strip()
            args = [a.strip() for a in args_str.split(",")]

            if tool_name in tools:
                result = tools[tool_name](*args)
                print(f"Tool '{tool_name}' returned: {result}")
                user_prompt = f"Your goal: {goal}\n\nYou used {tool_name} and got: {result}\n\nWhat is your next action?"
            else:
                print(f"Unknown tool: {tool_name}")
                break
        else:
            print("Agent response:", response)
            break

**Führen Sie diesen Agenten aus**:

python agent_loop.py

Das Modell entscheidet, ob es das Web durchsuchen oder eine Datei schreiben soll. In dieser simulierten Umgebung wird es „TOOL: search“ mit der Abfrage „Tokyo population“ ausgeben, ein simuliertes Ergebnis erhalten und dann „TOOL: write“ verwenden, um das Ergebnis zu speichern. Dies zeigt, wie generative Argumentation den agentischen Werkzeuggebrauch antreibt.

Autonomie und Kreation verbinden: Wichtige Designüberlegungen

1. Zustandsbehaftung und Gedächtnis

Ein reines generatives Modell hat kein Gedächtnis über die Eingabeaufforderung hinaus. Ein agentisches System muss den Zustand bewahren (z.B. einen Gesprächsverlauf oder eine Aufgabenliste). Bei der Kombination können Sie vergangene Aktionen in die Eingabeaufforderung einfügen, damit das generative Modell den Kontext kennt.

2. Werkzeugsicherheit und Einschränkungen

Autonomie bedeutet, der KI zu erlauben, auf der Grundlage ihrer Generierungen zu handeln. Sie müssen die Menge der Werkzeuge, die sie aufrufen kann, einschränken, Parameter validieren und für zerstörerische Operationen (z.B. Löschen von Dateien, Massen-E-Mails) den Menschen im Kreislauf implementieren. Der **Microsoft AI Blog** hat mehrere Artikel über verantwortungsvolle KI-Agenten veröffentlicht, die die Durchsetzung von Einschränkungen betonen.

3. Fehlerbehandlung und erneute Aufforderung

Generative Modelle können fehlerhafte Werkzeugaufrufe erzeugen. Ihre agentische Schicht sollte Antworten sorgfältig parsen, Ausnahmen abfangen und Fehler zur Selbstkorrektur an das Modell zurückgeben. Das obige Schleifenbeispiel zeigt dies: Wenn die Antwort des Modells nicht dem erwarteten Format entspricht, stoppt der Agent.

4. Das richtige Grundlagenmodell wählen

Verschiedene Modelle eignen sich für verschiedene Kombinationen. Für Code-Agent-Aufgaben sind Modelle, die für Funktionsaufrufe optimiert wurden (z.B. GPT‑4 Turbo, Claude 3), am besten. Für kreative Aufgaben können Modelle mit hoher Ausgabequalität und geringerer Latenz bevorzugt werden. Der **NVIDIA AI Blog** behandelt häufig domänenspezifisches Feintuning von Modellen für Simulations- und Robotik-Agenten.

Praxisbeispiele

Unternehmen und Forscher kombinieren diese Paradigmen bereits:

• **Autonome Codegenerierung und -überprüfung**: Ein Agent generiert Code, führt Tests durch und reicht einen Pull-Request ein – alles ohne dass ein Entwickler eine Zeile tippt. Generative Modelle erzeugen den Code, agentische Prozesse kümmern sich um die CI-Pipeline.
• **Persönliche KI-Assistenten**: Systeme wie Microsoft Copilot verwenden generative Modelle, um eine Anfrage zu verstehen, und dann agentische Fähigkeiten, um mit Kalender, E-Mail und Dokumenten zu interagieren.
• **Wissenschaftliche Forschung**: Ein Agent kann mit einem großen Sprachmodell eine Hypothese generieren, dann autonom Simulationen (z.B. auf NVIDIA-GPUs) durchführen und Ergebnisse analysieren.

Sowohl auf der **OpenAI News**- als auch auf der **Anthropic News**-Seite wird darauf hingewiesen, dass die Grenze zwischen Agent und Generator verschwimmt – Modelle werden darauf trainiert, direkt Funktionen aufzurufen und Abläufe zu planen, wodurch die agentische Schleife internalisiert wird.

Fazit

Generative KI und agentische KI sind keine Gegensätze; sie ergänzen sich. Generative Modelle liefern die kreative Engine, während agentische Frameworks die Autonomie zum Handeln bieten. Indem Sie Systeme bauen, in denen ein generatives Modell über Werkzeuge nachdenken und Handlungen ausführen kann – wie wir es mit den einfachen Dateischreib- und E-Mail-Agenten getan haben – erschließen Sie eine neue Stufe der Produktivität.

Beginnen Sie mit kleinen, klar abgegrenzten Aufgaben. Fügen Sie Einschränkungen hinzu, testen Sie Fehlerpfade und erweitern Sie die Autonomie schrittweise. Das kombinierte Paradigma wird die nächste Welle intelligenter Anwendungen definieren, von persönlichen Assistenten bis hin zu vollständig autonomen Forschungssystemen.

Jetzt haben Sie eine funktionierende Grundlage, um weiter zu experimentieren – versuchen Sie, eine echte E-Mail-API zu integrieren, eine Websuche hinzuzufügen oder ein Multi-Agenten-System zu bauen. Die Kombination ist der Punkt, an dem wahre Intelligenz beginnt.