Agentische KI vs. Generative KI: Neudefinition autonomer Intelligenz

KI-Agenten vs. Generative KI: Autonome Intelligenz neu definiert

Künstliche Intelligenz entwickelt sich von passiver Inhaltserstellung hin zu aktiver Entscheidungsfindung. Zwei große Paradigmen – **Generative KI** und **Agentische KI** – verändern die Art und Weise, wie Maschinen mit der Welt interagieren. Während sich Generative KI auf die Erstellung von Texten, Bildern, Code und Audio konzentriert, fügt Agentische KI eine Ebene der Autonomie hinzu: die Fähigkeit, wahrzunehmen, zu planen und im Namen von Nutzern zu handeln. Dieser Artikel untersucht die Unterschiede, Anwendungsfälle und praktische Schritte zum Aufbau eines einfachen agentischen Systems.

Grundlegende Konzepte verstehen

Was ist Generative KI?

Generative KI bezeichnet Modelle, die neue Inhalte auf der Grundlage von Mustern erstellen, die sie aus Trainingsdaten gelernt haben. Dazu gehören große Sprachmodelle (LLMs) wie GPT-4, Bildgeneratoren wie DALL-E und Code-Assistenten wie GitHub Copilot. Diese Systeme zeichnen sich durch die Erzeugung menschenähnlicher Ausgaben aus, benötigen jedoch in der Regel explizite Eingabeaufforderungen und führen keine mehrstufigen Aufgaben autonom aus.

Laut dem NVIDIA AI Blog verändert generative KI Branchen durch die Ermöglichung schneller Inhaltserstellung, von Marketingtexten bis hin zu synthetischen Daten für das Training. Diese Modelle bleiben jedoch reaktiv – sie reagieren auf Eingaben, ohne eigenständige Ziele zu setzen.

Was ist Agentische KI?

Agentische KI geht über die Generierung hinaus und umfasst **autonome Entscheidungsfindung**. Ein agentisches System kann:

• Hochrangige Ziele setzen oder empfangen
• Diese Ziele in Teilaufgaben unterteilen
• Werkzeuge (APIs, Datenbanken, Sensoren) nutzen, um Informationen zu sammeln
• Aktionen ausführen und Ergebnisse bewerten

Der Microsoft AI Blog hebt hervor, wie agentische Arbeitsabläufe in Unternehmenswerkzeuge wie Microsoft 365 Copilot integriert werden, wo KI E-Mails entwerfen, Besprechungen planen und Datenbanken abfragen kann, ohne dass der Mensch Schritt für Schritt Anweisungen geben muss. Anthropic News stellt ebenfalls fest, dass Claude-Modelle darauf ausgelegt sind, komplexe, mehrschrittige Aufgaben mit verbesserter Argumentation und Sicherheit zu bewältigen.

Hauptunterschiede

| Aspekt | Generative KI | Agentische KI | |--------|---------------|---------------| | **Primäre Funktion** | Inhaltserstellung | Autonome Aufgabenausführung | | **Interaktionsstil** | Eingabe-Antwort | Zielorientiert, mehrschrittig | | **Gedächtnis** | Auf Kontextfenster beschränkt | Kann langfristigen Zustand beibehalten | | **Werkzeugnutzung** | Selten | Kernfähigkeit | | **Entscheidungsfindung** | Keine (reaktiv) | Planung und Argumentation | | **Beispiel** | Ein Gedicht schreiben | Flug buchen, Wetter prüfen, Bestätigung senden |

Generative Modelle können Komponenten innerhalb eines agentischen Systems sein – zum Beispiel könnte ein LLM einen Plan erstellen, während der Agent ihn ausführt.

Praxisbeispiel: Aufbau eines einfachen agentischen Assistenten

Lassen Sie uns einen leichten Agenten bauen, der ein generatives KI-Modell (über die OpenAI-API) verwendet, um Fragen durch Internetsuche zu beantworten. Dies demonstriert die grundlegende agentische Schleife: wahrnehmen (Abfrage lesen), planen (entscheiden zu suchen), handeln (API aufrufen) und antworten.

Voraussetzungen

• Python 3.10 oder neuer
• pip-Paketmanager
• Ein OpenAI-API-Schlüssel (von [OpenAI News](https://openai.com/news/))
• Internetverbindung für API-Aufrufe

Schritt-für-Schritt-Installation

Erstellen Sie zunächst eine virtuelle Umgebung und installieren Sie die Abhängigkeiten:

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

Installieren Sie die erforderlichen Python-Pakete:

pip install openai requests python-dotenv

Richten Sie Ihren API-Schlüssel ein. Erstellen Sie eine `.env`-Datei in Ihrem Projektverzeichnis:

echo "OPENAI_API_KEY=ihr-schlüssel-hier" > .env

Ersetzen Sie `ihr-schlüssel-hier` durch Ihren tatsächlichen OpenAI-API-Schlüssel.

Nutzungsbeispiele

Erstellen Sie eine Datei namens `agent.py`:

import os
from dotenv import load_dotenv
import openai
import requests

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

def search_web(query):
    """Simuliert eine Websuche mit einer kostenlosen API (DuckDuckGo)"""
    url = f"https://api.duckduckgo.com/?q={query}&format=json"
    response = requests.get(url)
    return response.json().get("AbstractText", "Keine Ergebnisse gefunden.")

def agent_loop(user_input):
    """Agentische Schleife: Plan generieren, ausführen, antworten"""
    # Schritt 1: Generative KI nutzen, um zu entscheiden, was zu tun ist
    prompt = f"""Sie sind ein hilfreicher Assistent. Der Benutzer sagt: '{user_input}'. 
    Wenn der Benutzer nach sachlichen Informationen fragt, antworten Sie mit 'SEARCH: <suchanfrage>'. 
    Andernfalls antworten Sie direkt."""
    
    response = openai.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}],
        temperature=0
    )
    decision = response.choices[0].message.content.strip()
    
    # Schritt 2: Aktion basierend auf der Entscheidung ausführen
    if decision.startswith("SEARCH:"):
        query = decision.split("SEARCH:")[1].strip()
        search_result = search_web(query)
        # Schritt 3: Generative KI nutzen, um endgültige Antwort zu formulieren
        final_prompt = f"Basierend auf diesem Suchergebnis: '{search_result}', beantworten Sie die Anfrage des Benutzers: '{user_input}'"
        final_response = openai.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": final_prompt}],
        )
        print(final_response.choices[0].message.content)
    else:
        print(decision)

if __name__ == "__main__":
    while True:
        user_input = input("Sie: ")
        if user_input.lower() == "exit":
            break
        agent_loop(user_input)

Führen Sie den Agenten aus:

python agent.py

Beispielinteraktion:

Sie: Was ist die Hauptstadt von Frankreich?
Agent: Die Hauptstadt von Frankreich ist Paris.
Sie: Suche nach den neuesten KI-Nachrichten
Agent: [Basierend auf Suchergebnissen] OpenAI hat kürzlich GPT-4 Turbo angekündigt...

Dieses einfache Beispiel zeigt, wie generative KI (das LLM) die Argumentation antreibt, während die agentische Schleife Autonomie hinzufügt (Entscheidung, wann gesucht wird, dann Integration der Ergebnisse).

Fortgeschrittene agentische Muster

Reale agentische Systeme sind komplexer. Der Microsoft AI Blog beschreibt Agenten, die:

• **Mehrere Werkzeuge orchestrieren**: Eine Kalender-API aufrufen, dann eine E-Mail-API, dann ein CRM.
• **Dauerhaftes Gedächtnis bewahren**: Benutzereinstellungen über Sitzungen hinweg speichern.
• **Selbstkorrektur durchführen**: Wenn eine Suche keine Ergebnisse liefert, eine andere Abfrage versuchen.

Die Claude-Modelle von Anthropic verwenden **konstitutionelle KI**, um sicherere autonome Entscheidungen zu treffen – zum Beispiel die Ausführung von Aktionen zu verweigern, die Schaden verursachen könnten, selbst wenn der Benutzer sie anfordert.

Wann welcher Ansatz verwendet werden sollte

• **Verwenden Sie Generative KI allein**, wenn die Aufgabe eine einmalige Inhaltserstellung ist: einen Blogbeitrag schreiben, ein Bild generieren, Text übersetzen.
• **Verwenden Sie Agentische KI**, wenn die Aufgabe mehrere Schritte, externe Daten oder dauerhafte Ziele erfordert: Automatisierung des Kundensupports, Verwaltung eines Smart Homes, Durchführung von Recherchen.

Fazit

Generative KI und Agentische KI sind keine Konkurrenten – sie ergänzen sich. Generative Modelle liefern die Intelligenz (Argumentation, Sprachverständnis, Inhaltserstellung), während agentische Frameworks die Autonomie bereitstellen (Planung, Werkzeugnutzung, Ausführung). Wie der NVIDIA AI Blog anmerkt, liegt die Zukunft in **zusammengesetzten KI-Systemen**, die beide Paradigmen kombinieren, um reale Probleme zu lösen.

Der Bau Ihres eigenen Agenten ist jetzt mit nur wenigen Zeilen Python und einem API-Schlüssel zugänglich. Fangen Sie klein an – bauen Sie einen Recherche-Assistenten, einen persönlichen Terminplaner oder einen Aktienkursprüfer. Die Fähigkeiten, die Sie erlernen, lassen sich direkt auf die nächste Welle autonomer Intelligenz anwenden.