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

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

Die Landschaft der künstlichen Intelligenz durchläuft einen tiefgreifenden Wandel. In den letzten zwei Jahren dominierte Generative AI die Schlagzeilen mit ihrer Fähigkeit, Texte, Bilder, Code und Musik aus einfachen Eingabeaufforderungen zu erstellen. Tools wie ChatGPT, DALL-E und GitHub Copilot haben Produktivität und Kreativität neu definiert. Doch ein neues Paradigma zeichnet sich ab: Agentic AI. Anstatt lediglich Inhalte zu generieren, können Agentic-AI-Systeme Umgebungen wahrnehmen, Ziele setzen, Handlungsabläufe planen und Aufgaben autonom ausführen. Dieser Artikel untersucht die grundlegenden Unterschiede zwischen diesen beiden Paradigmen, warum der Wandel wichtig ist und wie Sie noch heute mit dem Aufbau agentischer Systeme beginnen können.

Was ist Generative AI?

Generative AI bezeichnet maschinelle Lernmodelle, die darauf trainiert sind, neue Daten zu erzeugen, die ihren Trainingsdaten ähneln. Die Kerntechnologie der meisten modernen generativen Systeme ist die Transformer-Architektur, die Aufmerksamkeitsmechanismen nutzt, um das nächste Token in einer Sequenz vorherzusagen. Diese Modelle werden auf riesigen Text-, Bild-, Audio- oder Videokorpora trainiert und lernen statistische Muster und Beziehungen.

Hauptmerkmale von Generative AI

• **Ausgabeorientiert**: Das Hauptziel ist die Erstellung von Inhalten – Text, Bilder, Code, Musik oder Video.
• **Eingabeaufforderungsgesteuert**: Benutzer geben eine Eingabeaufforderung, und das Modell generiert eine Antwort basierend auf seinem Training.
• **Zustandslos**: Jede Generierung ist typischerweise unabhängig von vorherigen Interaktionen (obwohl Speicher über Kontextfenster hinzugefügt werden kann).
• **Einzelschritt oder wenige Schritte**: Das Modell plant nicht über mehrere Schritte hinweg; es produziert eine einzelne Ausgabe pro Anfrage.

Beispiel: Generative AI in Aktion

Ein Benutzer fragt ein generatives Modell: "Schreibe eine Python-Funktion zur Berechnung von Fibonacci-Zahlen." Das Modell gibt aus:

def fibonacci(n):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    else:
        fib_seq = [0, 1]
        for i in range(2, n):
            fib_seq.append(fib_seq[-1] + fib_seq[-2])
        return fib_seq

Dies ist eine einzelne, statische Antwort. Das Modell debuggt den Code nicht, testet ihn nicht und setzt ihn nicht ein. Es generiert lediglich Inhalte.

Was ist Agentic AI?

Agentic-AI-Systeme sind darauf ausgelegt, in der Welt zu handeln. Sie kombinieren große Sprachmodelle (LLMs) oder andere KI-Komponenten mit Planung, Gedächtnis, Werkzeugnutzung und Feedbackschleifen. Ein Agent kann:

• **Wahrnehmen**: Seine Umgebung beobachten (Dateien, APIs, Datenbanken, Webseiten).
• **Planen**: Ein komplexes Ziel in Teilaufgaben zerlegen.
• **Handeln**: Befehle ausführen, APIs aufrufen, Dateien schreiben oder Software steuern.
• **Lernen**: Feedback aus Aktionen nutzen, um zukünftiges Verhalten anzupassen.

Hauptmerkmale von Agentic AI

• **Zielorientiert**: Der Agent verfolgt ein übergeordnetes Ziel, nicht nur eine einzelne Ausgabe.
• **Mehrschrittig**: Führt Abfolgen von Aktionen aus, oft mit Verzweigungen.
• **Zustandsbehaftet**: Behält Speicher über Interaktionen und Schritte hinweg.
• **Werkzeugnutzend**: Ruft externe Funktionen, APIs oder Dienste auf, um Informationen zu sammeln oder Veränderungen zu bewirken.
• **Autonom**: Arbeitet ohne ständigen menschlichen Eingriff.

Beispiel: Agentic AI in Aktion

Ein Benutzer gibt einem Agenten ein Ziel: "Recherchiere die neuesten KI-Modelle, fasse die Ergebnisse zusammen und speichere den Bericht in einer Datei." Der Agent könnte:

1. Das Web nach aktuellen KI-Nachrichten durchsuchen (mithilfe einer Such-API). 2. Artikel aus Quellen wie dem NVIDIA AI Blog oder OpenAI News lesen. 3. Jeden Artikel mithilfe eines generativen Modells zusammenfassen. 4. Zusammenfassungen zu einem strukturierten Bericht kombinieren. 5. Den Bericht in eine Markdown-Datei schreiben. 6. Dem Benutzer den Abschluss bestätigen.

Dies umfasst mehrere Schritte, Werkzeugaufrufe und bedingte Logik – weit mehr als eine einzelne Generierung.

Die Kernunterschiede

| Dimension | Generative AI | Agentic AI | |-----------|---------------|------------| | **Primäre Funktion** | Inhalte erstellen | Aufgaben ausführen | | **Interaktionsmodell** | Eingabeaufforderung → Antwort | Ziel → Plan → Aktionen → Ergebnis | | **Speicher** | Zustandslos (oder begrenzter Kontext) | Dauerhafter Zustand über Schritte hinweg | | **Werkzeugnutzung** | Keine (reine Generierung) | Integriert (APIs, Codeausführung, Suche) | | **Autonomie** | Keine (Benutzer steuert jede Anfrage) | Hoch (selbstgesteuerte Planung) | | **Fehlerbehandlung** | Keine (Ausgabe kann falsch sein) | Wiederholen, anpassen oder eskalieren | | **Komplexität** | Einzelschrittgenerierung | Mehrschritt-Orchestrierung |

Warum der Wandel wichtig ist

Der Wandel von Generative AI zu Agentic AI stellt einen Übergang von der *Kreation* zur *Aktion* dar. Generative AI ist ein leistungsstarkes Werkzeug zur Inhaltserstellung, überlässt die Ausführungslast jedoch dem Benutzer. Agentic-AI-Systeme können den Kreislauf schließen: Sie können nicht nur Code schreiben, sondern ihn auch ausführen, testen und bereitstellen. Sie können nicht nur ein Dokument zusammenfassen, sondern es auch an einen Kollegen senden.

Dieser Wandel hat praktische Auswirkungen auf Produktivität, Automatisierung und Softwareentwicklung. Der Microsoft AI Blog hat hervorgehoben, wie Agenten in Unternehmensworkflows helfen können, während Anthropic News Sicherheitsaspekte für autonome Systeme diskutiert hat. Der NVIDIA AI Blog bietet regelmäßig technische Einblicke in den Aufbau agentischer Architekturen.

Voraussetzungen für den Aufbau eines Agentic-AI-Systems

Bevor Sie in den Code eintauchen, stellen Sie sicher, dass Sie Folgendes haben:

• **Python 3.10+** auf Ihrem System installiert.
• **Einen OpenAI-API-Schlüssel** (oder Zugang zu einem anderen LLM-Anbieter). Sie können einen auf der [OpenAI-Plattform](https://platform.openai.com/) erhalten.
• **Grundlegende Vertrautheit mit der Befehlszeile** und Python-Virtual Environments.
• **Internetzugang** für API-Aufrufe und Paketinstallation.

Schritt-für-Schritt-Installation

Wir werden einen einfachen Agenten mit dem `langchain`-Framework erstellen, das Abstraktionen für LLMs, Werkzeuge und Agentenlogik bietet.

Schritt 1: Virtuelle Umgebung erstellen

Isolieren Sie Abhängigkeiten, um Konflikte zu vermeiden.

python3 -m venv agent_env
source agent_env/bin/activate  # Auf macOS/Linux
# Auf Windows: agent_env\Scripts\activate

Schritt 2: Erforderliche Pakete installieren

Installieren Sie `langchain`, `openai` und `python-dotenv` für die Verwaltung von Umgebungsvariablen.

pip install langchain openai python-dotenv

Schritt 3: API-Schlüssel einrichten

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

echo "OPENAI_API_KEY=ihr-api-schluessel-hier" > .env

Ersetzen Sie `ihr-api-schluessel-hier` durch Ihren tatsächlichen Schlüssel.

Schritt 4: Das Agentenskript erstellen

Erstellen Sie eine Datei namens `agent.py` und fügen Sie den folgenden Code hinzu:

import os
from dotenv import load_dotenv
from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType
from langchain.llms import OpenAI
from langchain.tools import tool
from langchain.utilities import SerpAPIWrapper  # Für Websuche

# Umgebungsvariablen laden
load_dotenv()

# LLM initialisieren
llm = OpenAI(temperature=0, model="gpt-3.5-turbo-instruct")

# Werkzeuge definieren
@tool
def search_web(query: str) -> str:
    """Durchsuche das Web nach aktuellen Informationen."""
    search = SerpAPIWrapper(serpapi_api_key=os.getenv("SERPAPI_API_KEY"))
    return search.run(query)

@tool
def write_file(filename: str, content: str) -> str:
    """Schreibe Inhalt in eine Datei."""
    with open(filename, "w") as f:
        f.write(content)
    return f"In {filename} geschrieben"

# Agent initialisieren
tools = [search_web, write_file]
agent = initialize_agent(
    tools, 
    llm, 
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, 
    verbose=True
)

# Agent ausführen
if __name__ == "__main__":
    result = agent.run(
        "Fasse den neuesten Artikel vom NVIDIA AI Blog zusammen und speichere die Zusammenfassung in nvidia_summary.md"
    )
    print(result)

Schritt 5: (Optional) Einen SerpAPI-Schlüssel erhalten

Für das Websuche-Werkzeug melden Sie sich bei [SerpAPI](https://serpapi.com/) an und fügen Sie Ihren Schlüssel zur `.env`-Datei hinzu:

echo "SERPAPI_API_KEY=ihr-serpapi-schluessel-hier" >> .env

Anwendungsbeispiele

Beispiel 1: Recherchieren und Zusammenfassen

Führen Sie den Agenten aus, um einen Artikel abzurufen und zusammenzufassen.

python agent.py

Der Agent wird: 1. Das Web nach dem neuesten NVIDIA AI Blog-Artikel durchsuchen. 2. Den Artikel lesen (falls zugänglich). 3. Eine Zusammenfassung erstellen. 4. Die Zusammenfassung in `nvidia_summary.md` schreiben.

Beispiel 2: Codegenerierung und -test

Modifizieren Sie den Agenten, um ein Python-Skript zu generieren und zu testen.

@tool
def run_python_code(code: str) -> str:
    """Python-Code ausführen und Ausgabe zurückgeben."""
    try:
        exec_globals = {}
        exec(code, exec_globals)
        return "Code erfolgreich ausgeführt."
    except Exception as e:
        return f"Fehler: {str(e)}"

tools.append(run_python_code)

# Agent mit neuen Werkzeugen neu initialisieren
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

result = agent.run(
    "Schreibe eine Python-Funktion zur Berechnung von Primzahlen bis 100 und teste sie dann durch Aufruf der Funktion."
)

Dies zeigt, wie ein Agent über die Generierung hinaus zur Validierung gehen kann.

Beispiel 3: Mehrschritt-Workflow

Erstellen Sie einen Agenten, der eine Abfolge von Aufgaben ausführt:

result = agent.run(
    "Suche zuerst nach den neuesten KI-Nachrichten vom Microsoft AI Blog. "
    "Fasse dann die Top-Story zusammen. Speichere schließlich die Zusammenfassung in einer Datei namens msft_ai_news.md"
)

Der Agent wird die Schritte planen, in der richtigen Reihenfolge ausführen und Abhängigkeiten verwalten.

Praktische Überlegungen

Zuverlässigkeit und Sicherheit

Agentic-AI-Systeme können Aktionen mit realen Konsequenzen ausführen. Stellen Sie immer sicher:

• **Ausgaben validieren**: Überprüfen Sie Dateien, API-Aufrufe und Codeausführung.
• **Grenzen setzen**: Beschränken Sie, welche Werkzeuge der Agent verwenden und welche Aktionen er ausführen kann.
• **Protokolle überwachen**: Verwenden Sie den ausführlichen Modus, um die Argumentation des Agenten zu verfolgen.

Fehlerbehandlung

Agenten können auf API-Fehler, ungültige Eingaben oder logische Sackgassen stoßen. Implementieren Sie Wiederholungslogik oder Ausweichstrategien:

from langchain.agents import AgentExecutor

# Benutzerdefinierte Fehlerbehandlung kann durch Umwickeln des Agenten hinzugefügt werden

Skalierung

Für den Produktionseinsatz sollten Sie Folgendes in Betracht ziehen:

• **Asynchrone Ausführung** zur Handhabung mehrerer Agenten.
• **Caching** zur Reduzierung der API-Kosten.
• **Zustandspersistenz** mithilfe von Datenbanken oder Redis.

Fazit

Die Entwicklung von Generative AI zu Agentic AI markiert einen grundlegenden Wandel in der Art und Weise, wie wir mit intelligenten Systemen interagieren. Generative AI zeichnet sich durch Kreation aus – die bedarfsgerechte Produktion von Texten, Bildern und Code. Agentic AI erweitert diese Fähigkeit auf Aktionen: Es plant, führt aus, lernt und passt sich an. Während generative Modelle die Kern-Engine für logisches Denken bleiben, verwandelt die agentische Hülle sie von passiven Werkzeugen in aktive Mitarbeiter.

Dieser Wandel ist bereits in Branchenentwicklungen sichtbar. Die Nachrichten-Updates von OpenAI konzentrieren sich zunehmend auf Funktionsaufrufe und Werkzeugnutzung. Der Microsoft AI Blog teilt Fallstudien von Agenten, die Unternehmensworkflows automatisieren. Anthropic News diskutiert Ausrichtung und Sicherheit für autonome Systeme. Der NVIDIA AI Blog bietet technische Anleitungen zum Aufbau agentischer Architekturen.

Für Entwickler ist die Einstiegshürde niedrig. Mit Frameworks wie LangChain, ein paar Zeilen Python und Zugang zu einer LLM-API können Sie Agenten bauen, die das Web durchsuchen, Dateien schreiben, Code ausführen und komplexe Workflows orchestrieren. Der Schlüssel ist, klein anzufangen – bauen Sie einen einfachen Agenten, testen Sie seine Grenzen und fügen Sie nach und nach weitere Fähigkeiten hinzu.

Die Zukunft der KI dreht sich nicht nur um die Generierung von Inhalten. Es geht darum, sinnvolle Aktionen in der Welt zu ergreifen. Agentic AI ist die Brücke zwischen dem, was wir uns vorstellen, und dem, was wir erreichen können.