Agentische KI vs. Generative KI: Den Wandel in autonomen Systemen verstehen

Agentische KI vs. Generative KI: Den Wandel in autonomen Systemen verstehen

Künstliche Intelligenz entwickelt sich atemberaubend schnell, und zwei Begriffe dominieren die Diskussion: **Generative KI** und **Agentische KI**. Obwohl beide bedeutende Durchbrüche darstellen, verfolgen sie grundlegend unterschiedliche Zwecke. Generative KI zeichnet sich durch die Erstellung von Inhalten aus – Text, Bilder, Code, Musik – basierend auf Mustern, die aus riesigen Datensätzen gelernt wurden. Agentische KI hingegen konzentriert sich auf autonome Entscheidungsfindung, zielorientiertes Verhalten und die Fähigkeit, in dynamischen Umgebungen zu handeln.

Dieser Artikel beleuchtet die Unterschiede, untersucht den Wandel von passiver Inhaltserstellung hin zu aktiven autonomen Systemen und bietet eine praktische, praxisnahe Implementierung, mit der Sie Ihren ersten agentischen Workflow erstellen können.

Was ist Generative KI?

Generative KI bezeichnet Modelle, die neue, originale Inhalte generieren, indem sie die statistische Struktur ihrer Trainingsdaten lernen. Die bekanntesten Beispiele sind große Sprachmodelle (LLMs) wie die GPT-Serie von OpenAI, Claude von Anthropic und Bildgeneratoren wie Stable Diffusion. Generative KI ist reaktiv – sie reagiert auf Eingabeaufforderungen mit plausiblen Ausgaben, plant jedoch nicht, denkt nicht über mehrere Schritte nach und ergreift keine externen Aktionen, es sei denn, sie wird explizit durch eine Orchestrierungsschicht gesteuert.

Im **Microsoft AI Blog** wird betont, wie generative KI die menschliche Kreativität und Produktivität steigern kann – vom Verfassen von E-Mails bis zur Generierung von Code-Snippets. Auch der **NVIDIA AI Blog** hebt die Rolle der generativen KI in Simulation, Wirkstoffforschung und Content-Erstellung hervor. Aber generative KI ist für sich genommen ein Werkzeug, das einen Menschen im Kreislauf erfordert, der Ziele definiert und Ergebnisse bewertet.

Was ist Agentische KI?

Agentische KI geht einen Schritt weiter. Ein agentisches System ist eine KI, die ihre Umgebung wahrnimmt, Ziele formuliert, Aktionen plant, diese ausführt und aus den Ergebnissen lernt – oft ohne menschliches Eingreifen bei jedem Schritt. Agentische KI ist proaktiv, persistent und in der Lage, komplexe mehrstufige Aufgaben zu bewältigen.

Die **Anthropic News**-Seite hat die Bedeutung von KI-Ausrichtung (Alignment) und robustem Verhalten in autonomen Agenten diskutiert. Auch die **OpenAI News** haben den Fortschritt von reiner Generierung hin zu Reasoning und Werkzeugnutzung thematisiert, wie er in der Entwicklung von Function Calling und der Einführung von Agenten, die im Internet surfen, Code ausführen und mit APIs interagieren können, zu sehen ist. Der **NVIDIA AI Blog** unterstreicht die agentische KI als die nächste Grenze, wo KI vom Co-Piloten zu einem autonomen System wird, das ganze Workflows verwalten kann.

Hauptunterschiede

| Aspekt | Generative KI | Agentische KI | |-------------------------|------------------------------------------------------|------------------------------------------------------------------| | **Primäre Funktion** | Inhalte generieren (Text, Bild, Code) | Aktionen zur Erreichung eines Ziels planen und ausführen | | **Interaktionsmodell** | Reaktiv (Eingabe → Ausgabe) | Proaktiv (Ziel → Plan → Aktion → Beobachten → Iterieren) | | **Gedächtnis** | Typischerweise zustandslos (oder begrenzter Kontext) | Enthält oft Langzeitgedächtnis und Zustandsverfolgung | | **Werkzeugnutzung** | Standardmäßig keine (kann per Orchestrierung ergänzt werden) | Entwickelt, um APIs, Datenbanken oder physische Geräte aufzurufen | | **Autonomie** | Gering (benötigt menschliche Lenkung) | Hoch (kann über längere Zeiträume unabhängig arbeiten) | | **Beispiele** | ChatGPT schreibt ein Gedicht, DALL·E erzeugt ein Bild| AutoGPT erledigt eine Recherche-Aufgabe, selbstfahrende KI-Agenten|

Der Wandel hin zu autonomen Systemen

Der Übergang von generativer zu agentischer KI ist nicht nur ein Technologie-Upgrade – er stellt einen Paradigmenwechsel dar. Generative KI-Modelle sind das „Gehirn“, aber agentische Architekturen liefern den „Körper“ – die Fähigkeit zu fühlen, zu planen, zu handeln und zu lernen. Der **Microsoft AI Blog** hat untersucht, wie sich Copilot-Erlebnisse zu autonomen Orchestrierungsschichten entwickeln. OpenAIs **Function Calling** und **Assistants API** sind direkte Schritte zur Ermöglichung von Agenten. Der **NVIDIA AI Blog** diskutiert die Notwendigkeit fortschrittlicher Simulationsumgebungen, in denen Agenten vor dem Einsatz sicher trainiert werden können.

Reale agentische Systeme existieren bereits: Kundendienst-Bots, die Support-Tickets eskalieren, Code-Review-Agenten, die Fehler beheben, und Forschungsassistenten, die Informationen aus verschiedenen Quellen sammeln und synthetisieren. Der Wandel beschleunigt sich, weil generative Modelle zuverlässig genug geworden sind, um als Reasoning-Kern eines Agenten zu dienen, und Open-Source-Frameworks (LangChain, CrewAI, AutoGen) den Bau solcher Systeme einfach machen.

Praktische Implementierung: Aufbau eines einfachen agentischen Workflows

In diesem Abschnitt bauen wir einen minimalen Agenten, der ein generatives KI-Modell (OpenAIs GPT-4) verwendet, um eine Aufgabe autonom auszuführen: ein Thema recherchieren, die Ergebnisse zusammenfassen und die Zusammenfassung in einer lokalen Datei speichern. Dies veranschaulicht die Kernschleife eines agentischen Systems: wahrnehmen, planen, handeln und persistieren.

Voraussetzungen

• Python 3.8 oder neuer
• pip-Paketmanager
• Ein OpenAI-API-Schlüssel (erhältlich über die OpenAI-Plattform)
• Ein Terminal oder eine Befehlszeilenumgebung
• Internetverbindung für API-Aufrufe

Schritt-für-Schritt-Installation

#### 1. Virtuelle Umgebung erstellen und aktivieren (empfohlen)

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

Dies isoliert Abhängigkeiten und vermeidet Konflikte mit systemweiten Paketen.

#### 2. Erforderliche Bibliotheken installieren

pip install openai langchain python-dotenv requests

• `openai` – offizieller Client für die OpenAI-API.
• `langchain` – Framework zum Erstellen agentischer Ketten und Werkzeuge.
• `python-dotenv` – lädt API-Schlüssel aus einer `.env`-Datei.
• `requests` – für mögliche Webabfragen (in LangChain integriert, aber hier explizit gehalten).

#### 3. Umgebungsvariablen einrichten

Erstellen Sie eine Datei mit dem Namen `.env` in Ihrem Projektverzeichnis:

OPENAI_API_KEY=ihr-tatsächlicher-api-schlüssel-hier

Laden Sie diese dann in Ihrem Python-Code frühzeitig:

from dotenv import load_dotenv
load_dotenv()

#### 4. Das Agenten-Skript schreiben

Erstellen Sie eine Datei mit dem Namen `research_agent.py` mit folgendem Inhalt:

import os
from langchain.agents import initialize_agent, AgentType
from langchain.chat_models import ChatOpenAI
from langchain.tools import Tool
from langchain.memory import ConversationBufferMemory
import requests
from datetime import datetime

# --- 1. Werkzeuge definieren, die der Agent nutzen kann ---

def search_web(query: str) -> str:
    """Simuliert eine Websuche (in Produktion echte API wie SerpAPI verwenden)."""
    # In einer echten Implementierung würde man eine Such-API aufrufen.
    # Für Demonstrationszwecke geben wir einen Platzhalter zurück.
    return f"Platzhalter-Ergebnis für '{query}': Das Thema wird in KI-Blogs breit diskutiert."

def save_summary(text: str) -> str:
    """Speichert eine Zusammenfassung in einer datei mit Zeitstempel."""
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"summary_{timestamp}.txt"
    with open(filename, "w") as f:
        f.write(text)
    return f"Zusammenfassung gespeichert unter {filename}"

tools = [
    Tool(
        name="Search",
        func=search_web,
        description="Durchsucht das Web nach aktuellen Informationen zu einem Thema."
    ),
    Tool(
        name="FileWriter",
        func=save_summary,
        description="Speichert Text in einer Datei auf dem lokalen Dateisystem."
    )
]

# --- 2. Das generative Modell initialisieren (Gehirn) ---

llm = ChatOpenAI(model="gpt-4", temperature=0.2)

# --- 3. Gedächtnis einrichten, damit der Agent Kontext behalten kann ---

memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

# --- 4. Den Agenten erstellen ---

agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory,
    verbose=True,
    handle_parsing_errors=True
)

# --- 5. Den Agenten mit einem Ziel ausführen ---

if __name__ == "__main__":
    goal = "Recherchiere den Unterschied zwischen Agentischer KI und Generativer KI, schreibe dann eine kurze Zusammenfassung und speichere sie in einer Datei."
    print(f"\n--- Agentenziel: {goal} ---\n")
    result = agent.run(goal)
    print(f"\nEndgültige Agentenausgabe:\n{result}")

Erklärung des Codes

• **Zeile für Zeile**: Das Skript importiert LangChain-Komponenten, definiert zwei Werkzeuge (`Search` und `FileWriter`), initialisiert das GPT-4-Modell als Reasoning-Kern, fügt ein Gesprächsgedächtnis hinzu und kombiniert alles zu einem `CHAT_CONVERSATIONAL_REACT_DESCRIPTION`-Agenten. Dieser Agent kann schrittweise denken, nach Informationen suchen (simuliert) und Dateien schreiben.
• **Gedächtnis** (`ConversationBufferMemory`) ermöglicht dem Agenten, sich während des Laufs an vorherige Aktionen und Ergebnisse zu erinnern.
• **Verbose-Modus** gibt den Gedankengang des Agenten aus und zeigt, wie er Werkzeuge einsetzt.

Anwendungsbeispiele

#### Den Recherche-Agenten ausführen

python research_agent.py

Sie werden eine Ausgabe ähnlich dieser sehen:

> Neue AgentExecutor-Kette betreten...
Gedanke: Ich muss zuerst das Thema recherchieren. Lassen Sie mich nach "Agentische KI vs Generative KI" suchen.
Aktion: Search
Aktionseingabe: "Agentische KI vs Generative KI Unterschiede"
Beobachtung: Platzhalter-Ergebnis für 'Agentische KI vs Generative KI Unterschiede': ...
Gedanke: Jetzt habe ich Informationen. Ich werde eine Zusammenfassung schreiben und speichern.
Aktion: FileWriter
Aktionseingabe: "Agentische KI konzentriert sich auf autonome Entscheidungsfindung..."
Beobachtung: Zusammenfassung gespeichert unter summary_20250328_120500.txt
> Kette beendet.

Der Agent hat autonom zwei Schritte geplant, ausgeführt und eine Datei erstellt.

#### Das Ziel anpassen

Ändern Sie die Variable `goal`, um zu experimentieren:

goal = "Finde die neuesten Nachrichten über Agentische KI vom Microsoft AI Blog und erstelle eine Aufzählungsliste, die als Markdown-Datei gespeichert wird."

Der Agent wird versuchen zu suchen (hier simuliert) und anschließend die formatierte Liste speichern.

#### Ausführen ohne simulierte Suche (echte Integration)

Um ein echtes Suchwerkzeug hinzuzufügen, ersetzen Sie `search_web` durch eine Funktion, die die SerpAPI oder die Bing-Suche-API aufruft. Das Muster bleibt gleich – Agenten sind darauf ausgelegt, mit benutzerdefinierten Werkzeugen erweitert zu werden.

Erweiterte Konfiguration (optional)

• **Mehrere Agenten**: Verwenden Sie Frameworks wie `CrewAI` oder `AutoGen` (basierend auf LangChain), um Teams spezialisierter Agenten zu erstellen, die zusammenarbeiten.
• **Langlaufende Agenten**: Fügen Sie eine Schleife und Fehlerbehandlungslogik hinzu. Der **NVIDIA AI Blog** und **Anthropic News** haben Sicherheitsaspekte für persistente Agenten diskutiert.

Fazit

Der Wandel von generativer KI zu agentischer KI markiert eine entscheidende Entwicklung in der Art und Weise, wie wir intelligente Systeme bauen und einsetzen. Generative Modelle geben uns die „Fähigkeit, uns etwas vorzustellen“, indem sie neuartige Inhalte erzeugen. Agentische Systeme geben uns die „Fähigkeit zu handeln“, indem sie diesen generativen Kern mit Gedächtnis, Planung und Werkzeugnutzung kombinieren. Wie die **OpenAI News** und der **Microsoft AI Blog** betonen, liegt die Zukunft in autonomen Systemen, die zuverlässig über lange Zeiträume operieren können. Der **NVIDIA AI Blog** hebt die Infrastruktur hervor – beschleunigtes Rechnen und Simulation – die zum Trainieren und Ausführen dieser Agenten benötigt wird.

Der Bau eines einfachen Agenten, wie wir es oben getan haben, zeigt, dass die Einstiegshürde niedrig ist. Mit ein paar Bibliotheken und einer generativen Modell-API können Sie ein System schaffen, das selbstständig plant, ausführt und Ergebnisse speichert. Wenn Sie vom Experimentieren zur Produktion übergehen, denken Sie daran, Sicherheit, Beobachtbarkeit und Ausrichtung (Alignment) zu berücksichtigen – Themen, die **Anthropic News** lautstark angesprochen hat.

Das Zeitalter der generativen KI hat uns das Rohmaterial gegeben. Das Zeitalter der agentischen KI wird damit bauen.