Agentische KI vs. Generative KI: Der Wandel von der Inhaltserstellung zum autonomen Handeln

Agentic KI vs. Generative KI: Der Wandel von der Inhaltserstellung zum autonomen Handeln

Die Landschaft der künstlichen Intelligenz durchläuft einen tiefgreifenden Wandel. In den letzten Jahren stand die generative KI im Rampenlicht – Modelle, die Texte, Bilder, Code und Musik mit erstaunlicher Sprachgewandtheit erstellen. Doch ein neues Paradigma zeichnet sich ab: die agentische KI. Während generative KI hervorragend darin ist, auf Abruf Inhalte zu produzieren, baut die agentische KI auf dieser Grundlage auf, um autonome, zielgerichtete Handlungen auszuführen. Dieser Artikel untersucht die Unterschiede, die technischen Grundlagen und wie Entwickler noch heute mit dem Bau agentischer Systeme beginnen können.

Was ist generative KI?

Generative KI bezeichnet Modelle, die neue Daten ähnlich ihren Trainingsdaten erzeugen. Dazu gehören große Sprachmodelle (LLMs) wie GPT-4, Bildgeneratoren wie DALL-E und Code-Assistenten wie GitHub Copilot. Die Kernkompetenz ist die **Inhaltserstellung**: Auf eine Eingabeaufforderung hin produziert das Modell eine kohärente Ausgabe – sei es ein Absatz, ein Bild oder eine Funktion.

Generative KI ist reaktiv. Sie wartet auf eine Benutzereingabe, verarbeitet sie und gibt ein Ergebnis zurück. Sie initiiert keine Aktionen, setzt keine Ziele oder arbeitet über längere Zeiträume. Ihre Stärke liegt in ihrer Fähigkeit, menschliche Kreativität und Wissen nachzuahmen.

Was ist agentische KI?

Agentische KI erweitert die generative KI um Autonomie, Zielsetzung und mehrstufige Argumentation. Ein agentisches System kann:

• Seine Umgebung wahrnehmen (über APIs, Sensoren oder Texteingaben)
• Pläne formulieren, um ein benutzerdefiniertes Ziel zu erreichen
• Aktionen ausführen (APIs aufrufen, Dateien schreiben, E-Mails senden)
• Ergebnisse überwachen und sein Verhalten anpassen
• Über längere Zeiträume ohne menschliches Eingreifen operieren

Kurz gesagt: Die agentische KI bewegt sich von **"Erstelle dies für mich"** zu **"Erreiche dies für mich."** Dieser Wandel wird durch Forschung und Produkte von Organisationen wie OpenAI, Microsoft und Anthropic sowie durch Open-Source-Frameworks vorangetrieben.

Hauptunterschiede: Generativ vs. Agentisch

| Aspekt | Generative KI | Agentische KI | |--------|---------------|---------------| | Primäre Funktion | Inhaltserstellung | Autonomes Handeln | | Interaktionsmodell | Einmalige Aufforderung/Antwort | Mehrstufig, zielorientiert | | Zustandsbehaftung | Zustandslos (pro Anfrage) | Behält Zustand über Schritte hinweg | | Werkzeugnutzung | Keine oder begrenzt | API-Aufrufe, Datei-E/A, Websuche | | Planung | Keine | Zerlegt Ziele in Teilaufgaben | | Fehlerbehebung | Keine | Wiederholungen, Ausweichlösungen, Selbstkorrektur |

Wie agentische KI funktioniert

Im Kern verwendet ein agentisches System ein generatives Modell als sein "Gehirn", umgibt es jedoch mit einer **Planungsschleife**, einer **Werkzeugausführungs-Engine** und einem **Speichersystem**. Die typische Architektur:

1. **Der Benutzer gibt ein übergeordnetes Ziel vor** (z. B. "Recherchiere die neuesten KI-Trends und sende mir eine Zusammenfassung per E-Mail"). 2. **Der Agent plant**: Das LLM zerlegt das Ziel in Schritte (z. B. Web durchsuchen, Artikel lesen, zusammenfassen, E-Mail senden). 3. **Der Agent führt aus**: Er ruft Schritt für Schritt Werkzeuge auf (Websuche, Dateischreiber, E-Mail-API). 4. **Der Agent beobachtet und passt sich an**: Er überprüft Ergebnisse, behandelt Fehler und plant bei Bedarf neu. 5. **Der Agent schließt ab**: Er gibt das endgültige Ergebnis zurück oder setzt die Überwachung fort.

Frameworks wie LangChain, AutoGPT und Microsofts Semantic Kernel bieten das Gerüst für den Bau solcher Systeme.

Praktische Umsetzung: Bau eines einfachen Agenten

Lassen Sie uns ein minimales agentisches System mit Python und LangChain bauen. Dieser Agent nimmt ein natürlichsprachliches Ziel entgegen, verwendet ein Suchwerkzeug und erstellt einen Bericht.

Voraussetzungen

• Python 3.10 oder neuer
• Ein OpenAI-API-Schlüssel (oder ein anderer LLM-Anbieter)
• Ein Such-API-Schlüssel (z. B. SerpAPI oder Tavily)
• Grundlegende Vertrautheit mit der Kommandozeile

Schritt-für-Schritt-Installation

**Schritt 1: Erstellen Sie eine virtuelle Umgebung und installieren Sie die Abhängigkeiten.**

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

**Schritt 2: Installieren Sie die erforderlichen Pakete.**

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

**Schritt 3: Richten Sie Umgebungsvariablen ein.**

Erstellen Sie eine `.env`-Datei in Ihrem Projektverzeichnis:

OPENAI_API_KEY=ihr-openai-api-schluessel-hier
TAVILY_API_KEY=ihr-tavily-api-schluessel-hier

**Schritt 4: Schreiben Sie das Agentenskript.**

Erstellen Sie eine Datei namens `simple_agent.py` mit folgendem Code:

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import Tool
from langchain_community.tools import TavilySearchResults
from langchain import hub

# Umgebungsvariablen laden
load_dotenv()

# LLM initialisieren
llm = ChatOpenAI(model="gpt-4", temperature=0)

# Suchwerkzeug initialisieren
search_tool = TavilySearchResults(max_results=3)

# Benutzerdefiniertes Werkzeug zur Zusammenfassung definieren
def summarize_text(text: str) -> str:
    """Fasst einen gegebenen Text zusammen."""
    response = llm.invoke(f"Fasse diesen Text in 3 Aufzählungspunkten zusammen:\n{text}")
    return response.content

summary_tool = Tool(
    name="TextSummarizer",
    func=summarize_text,
    description="Nützlich zum Zusammenfassen langer Texte. Die Eingabe sollte der zusammenzufassende Text sein."
)

# Agent erstellen
tools = [search_tool, summary_tool]
prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# Agent ausführen
goal = "Finde die neuesten Nachrichten über agentische KI und schreibe eine kurze Zusammenfassung des Top-Artikels."
result = agent_executor.invoke({"input": goal})
print("\n--- Endgültige Ausgabe ---")
print(result["output"])

**Schritt 5: Führen Sie den Agenten aus.**

python simple_agent.py

Erklärung des Codes

• `TavilySearchResults`: Ein Echtzeit-Websuchwerkzeug. Der Agent ruft es auf, um Informationen zu sammeln.
• `TextSummarizer`: Ein benutzerdefiniertes Werkzeug, das das LLM verwendet, um Inhalte zu verdichten.
• `create_react_agent`: Erstellt einen Agenten, der das ReAct-Muster (Reasoning + Acting) verwendet. Der Agent denkt, handelt, beobachtet und wiederholt.
• `AgentExecutor`: Führt die Schleife aus und übernimmt Werkzeugaufrufe und Fehlerbehebung.

Anwendungsbeispiele

Beispiel 1: Recherche und Bericht

Ziel: "Recherchiere die Auswirkungen generativer KI auf die Bildung und schreibe einen Bericht, der in einer Datei gespeichert wird."

from langchain.tools import Tool

def write_file(filename: str, content: str) -> str:
    """Schreibt Inhalt in eine Datei."""
    with open(filename, 'w') as f:
        f.write(content)
    return f"Datei {filename} erfolgreich geschrieben."

file_tool = Tool(
    name="FileWriter",
    func=write_file,
    description="Schreibt Text in eine Datei. Die Eingabe sollte 'Dateiname|Inhalt' sein."
)

# file_tool zur Werkzeugliste hinzufügen und erneut ausführen

Beispiel 2: Automatisierter E-Mail-Zusammenfasser

Ziel: "Lies die neuesten E-Mails aus meinem Posteingang (simuliert) und fasse die Top 3 zusammen."

Sie würden ein E-Mail-Werkzeug hinzufügen (z. B. mit der Gmail-API) und den Agenten über Nachrichten iterieren lassen.

Beispiel 3: Mehrstufige Datenpipeline

Ziel: "Rufe die neuesten Aktienkurse für AAPL, GOOGL und MSFT ab, berechne den Durchschnitt und zeichne ein Diagramm."

Der Agent würde eine Finanzdaten-API aufrufen, Berechnungen durchführen und eine Plotting-Bibliothek verwenden.

Der Wandel: Vom Passiven zum Proaktiven

Generative KI ist wie ein brillanter Assistent, der nur spricht, wenn er angesprochen wird. Agentische KI ist wie ein proaktiver Mitarbeiter, der Ihre Ziele versteht, die Arbeit plant, ausführt und Bericht erstattet. Dieser Wandel hat tiefgreifende Auswirkungen:

• **Produktivität**: Agenten können komplexe, mehrstündige Aufgaben ohne Aufsicht erledigen.
• **Integration**: Agenten verbinden sich mit bestehenden Systemen (CRMs, Datenbanken, APIs), um mit realen Daten zu arbeiten.
• **Skalierbarkeit**: Ein einzelner Agent kann Dutzende paralleler Arbeitsabläufe verwalten.

Microsofts KI-Blog betont, dass Agenten zu "einer neuen Klasse von Anwendungen werden, die im Namen von Benutzern denken, planen und handeln können." Ähnlich weist Anthropics Forschung zu verfassungsgemäßer KI und Werkzeugnutzung auf sicherere, leistungsfähigere Agenten hin.

Herausforderungen und Überlegungen

Agentische KI ist nicht ohne Risiken:

• **Zuverlässigkeit**: Agenten können halluzinieren oder falsche Werkzeugaufrufe tätigen. Robuste Fehlerbehandlung und menschliche Aufsicht sind entscheidend.
• **Sicherheit**: Agenten mit Zugriff auf sensible APIs oder Dateien müssen in einer Sandbox laufen und berechtigungsbeschränkt sein.
• **Kosten**: Jeder Agentenschritt verbraucht Tokens und API-Aufrufe. Langlaufende Aufgaben können teuer sein.
• **Ausrichtung**: Sicherzustellen, dass die Aktionen des Agenten der Benutzerabsicht entsprechen, erfordert sorgfältiges Prompt-Engineering und Tests.

Die Zukunft: Generativ + Agentisch

Die beiden Paradigmen schließen sich nicht gegenseitig aus. Die leistungsfähigsten Systeme werden generative und agentische Fähigkeiten kombinieren. Zum Beispiel:

• Ein generatives Modell erstellt einen E-Mail-Entwurf.
• Ein agentisches System sendet ihn, überwacht Antworten und plant Nachfassaktionen.
• Ein weiteres agentisches System recherchiert das Unternehmen des Empfängers und aktualisiert den E-Mail-Inhalt entsprechend.

NVIDIAs KI-Blog hebt hervor, wie generative Modelle in autonome Systeme für Robotik und Simulation eingebettet werden. OpenAIs Nachrichtenbereich diskutiert "Agenten, die im Web surfen, Apps nutzen und Aufgaben in Ihrem Namen ausführen können."

Fazit

Der Wandel von generativer KI zu agentischer KI stellt eine Reifung des Feldes dar. Generative KI gab uns die Fähigkeit zu erschaffen; agentische KI gibt uns die Fähigkeit zu handeln. Durch die Kombination der Argumentationskraft von LLMs mit Werkzeugnutzung, Planung und Gedächtnis können Entwickler Systeme bauen, die nicht nur Fragen beantworten, sondern Probleme lösen.

Ob Sie einen persönlichen Forschungsassistenten, einen automatisierten Kundensupport-Bot oder einen Datenpipeline-Manager bauen – die Prinzipien sind dieselben: Definieren Sie ein Ziel, statten Sie den Agenten mit Werkzeugen aus und lassen Sie ihn iterieren. Die obigen Codebeispiele bieten einen Ausgangspunkt. Da Frameworks besser werden und Kosten sinken, wird agentische KI so alltäglich werden wie generative KI heute.

Die nächste Innovationswelle wird nicht davon handeln, was KI erschaffen kann, sondern was sie erreichen kann.