Agentische KI vs Generative KI: Der Aufstieg der autonomen Agenten

Agentic KI vs. Generative KI: Der Aufstieg autonomer Agenten

Künstliche Intelligenz hat einen entscheidenden Wendepunkt erreicht. In den letzten Jahren stand vor allem die **Generative KI** im Rampenlicht – Modelle, die auf menschliche Eingaben hin Texte, Bilder, Code und mehr erzeugen können. Werkzeuge wie ChatGPT, DALL·E und GitHub Copilot haben kreative und technische Arbeit demokratisiert. Doch nun zeichnet sich eine neue Welle ab: **Agentic KI**. Statt nur eine einzelne Antwort zu generieren, können agentische Systeme planen, mehrstufige Aufgaben ausführen, externe Werkzeuge nutzen und ihr Verhalten auf Basis von Ergebnissen anpassen. Dieser Artikel untersucht die Unterschiede zwischen diesen beiden Paradigmen, erklärt, warum autonome Agenten an Bedeutung gewinnen, und bietet eine praktische Schritt-für-Schritt-Anleitung zum Bau eines eigenen Agenten.

Was ist Generative KI?

Generative KI bezeichnet Modelle, die darauf trainiert sind, neue Inhalte zu erzeugen, die den Mustern ihrer Trainingsdaten ähneln. Große Sprachmodelle (Large Language Models, LLMs) wie GPT‑4, Claude und Llama sind die bekanntesten Beispiele. Auf einen Prompt hin generieren sie eine Antwort, indem sie die wahrscheinlichsten nächsten Token vorhersagen. Sie sind reaktiv: Die Interaktion endet, sobald die Ausgabe geliefert wurde.

Diese Modelle sind besonders geeignet für Aufgaben wie:

• Verfassen von E-Mails, Berichten oder Code.
• Beantworten von Sachfragen (mit Kontext).
• Zusammenfassen langer Dokumente.
• Erstellen von Bildern aus Textbeschreibungen.

Dennoch hat generative KI inhärente Grenzen. Sie verfügt über kein Gedächtnis für vergangene Interaktionen (jenseits des Kontextfensters), kann keine externen Werkzeuge nativ nutzen und plant keine Handlungsabläufe. Ein einziger Prompt liefert eine einzige Antwort – ist diese falsch oder unvollständig, muss der Nutzer die Eingabe manuell verfeinern.

Was ist Agentic KI?

Agentic KI führt Autonomie und zielorientiertes Verhalten ein. Ein **Agent** ist ein System, das Folgendes kann:

• Ein übergeordnetes Ziel logisch erfassen.
• Dieses Ziel in Teilaufgaben zerlegen.
• Externe Werkzeuge (Websuche, Taschenrechner, APIs, Datenbanken) nutzen, um Informationen zu sammeln.
• Zwischenergebnisse bewerten und seinen Plan anpassen.
• Erinnerungen über Interaktionen hinweg speichern.

Der Agent erzeugt nicht einfach Text; er agiert als digitaler Mitarbeiter, der Arbeitsabläufe ausführen kann. Der Aufstieg der Agentic KI wird durch Frameworks wie **LangChain**, **AutoGPT** und **Microsofts Copilot‑Ökosystem** beschleunigt. Diese Frameworks umhüllen ein LLM mit Fähigkeiten zur Planung, Werkzeugnutzung und Speicherung.

#### Wesentliche Unterschiede

| Merkmal | Generative KI | Agentic KI | |---------|---------------|------------| | Interaktionstyp | Einmaliger Prompt → Antwort | Mehrschrittig, zielgerichtet | | Gedächtnis | Beschränkt auf Kontextfenster | Beständig, oft extern | | Werkzeugnutzung | Keine (außer über API‑Aufruf durch den Nutzer) | Native Werkzeugaufrufe | | Planung | Keine | Selbstgesteuerte Aufgabenzerlegung | | Anpassungsfähigkeit | Keine | Kann wiederholen, verfeinern oder Ansatz ändern |

Beide Paradigmen schließen sich nicht gegenseitig aus. Agentic KI baut auf generativen Modellen auf; das LLM liefert die Denkmaschine, während das Agenten‑Framework die Orchestrierung übernimmt.

Warum die Verschiebung hin zu Agenten?

Große Branchenankündigungen unterstreichen diesen Trend. Die Einführung der **Assistants API** durch OpenAI, Microsofts **Copilot**‑Integrationen und die Forschung von Anthropic zur **Werkzeugnutzung** deuten alle auf eine Zukunft hin, in der KI nicht nur Fragen beantwortet, sondern Aufgaben erledigt. Der KI‑Blog von NVIDIA befasst sich häufig mit der Einbettung von Agenten in Simulation und Robotik. Der gemeinsame Nenner: Generative Modelle sind mächtig, aber passiv; Agenten sind aktiv.

Voraussetzungen für den Bau eines Agenten

Um die praktischen Beispiele in diesem Artikel nachvollziehen zu können, benötigst du:

• **Python 3.9 oder neuer**, installiert auf deinem Rechner.
• **pip** Paketmanager.
• Einen **API‑Schlüssel** eines generativen KI‑Anbieters (z. B. OpenAI, Anthropic oder ein lokales Modell via Ollama).
• **Internetzugang** zum Installieren von Paketen und für API‑Aufrufe.

Wir verwenden das **LangChain**‑Framework, da es weit verbreitet, gut dokumentiert ist und mehrere LLMs unterstützt. Der Einfachheit halber nutzen wir GPT‑4o (oder GPT‑4‑turbo) von OpenAI als Denkmaschine.

Schritt-für-Schritt-Installation

#### 1. Python‑Virtual‑Environment einrichten

Es ist gute Praxis, Abhängigkeiten zu isolieren. Öffne dein Terminal und führe aus:

python3 -m venv agent_env

Dadurch wird ein Verzeichnis `agent_env` mit einer lokalen Python‑Umgebung erstellt.

Aktiviere es:

• Auf macOS/Linux: `source agent_env/bin/activate`
• Auf Windows: `agent_env\Scripts\activate`

Deine Terminal‑Eingabeaufforderung ändert sich, um die aktive Umgebung anzuzeigen.

#### 2. Erforderliche Python‑Pakete installieren

Wir benötigen `langchain`, `langchain-openai` (für die Schnittstelle zu OpenAI), `python-dotenv` (zum Verwalten von API‑Schlüsseln) und `openai` selbst.

pip install langchain langchain-openai python-dotenv openai

Wenn du eine Websuche als Werkzeug verwenden möchtest, installiere auch `duckduckgo-search` (kostenlos, kein API‑Schlüssel nötig):

pip install duckduckgo-search

#### 3. API‑Schlüssel konfigurieren

Erstelle eine Datei namens `.env` in deinem Projektordner und füge deinen OpenAI‑API‑Schlüssel hinzu:

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

**Wichtig:** Hartcodiere API‑Schlüssel niemals in deinen Skripten. Verwende Umgebungsvariablen, wie wir sie mit `python-dotenv` laden werden.

#### 4. Installation überprüfen

Führe ein kurzes Python‑Skript aus, um sicherzustellen, dass alles funktioniert:

# Agentic KI vs. Generative KI: Der Aufstieg autonomer Agenten
from dotenv import load_dotenv
import os
from langchain_openai import ChatOpenAI

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
    raise ValueError("API-Schlüssel nicht gefunden. Überprüfe deine .env-Datei.")

llm = ChatOpenAI(model="gpt-4o", temperature=0)
response = llm.invoke("Sage 'Hallo von Agentic AI'")
print(response.content)

Wenn du die Ausgabe `Hallo von Agentic AI` siehst, ist deine Umgebung bereit.

Anwendungsbeispiele

Wir implementieren nun zwei Szenarien: eine **rein generative** Abfrage und eine **agentische** Aufgabe, die ein Werkzeug verwendet.

#### Beispiel 1: Generative KI – eine einfache Frage & Antwort

Dies ist der klassische, nicht‑agentische Ansatz. Das LLM erhält einen einzigen Prompt und gibt eine einzige Antwort zurück.

# generative_example.py
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
import os

load_dotenv()
llm = ChatOpenAI(model="gpt-4o", temperature=0)

prompt = "Was ist die Hauptstadt von Frankreich und wie viele Einwohner hat sie?"
response = llm.invoke(prompt)
print(response.content)

**Ausgabe:** *Die Hauptstadt von Frankreich ist Paris. Im Jahr 2024 beträgt die Einwohnerzahl innerhalb der Stadtgrenzen etwa 2,1 Millionen, im Großraum über 11 Millionen.*

Das Modell beantwortet die Frage direkt. Es gibt keine Nachfrage, keine Überprüfung. Sollte das Modell eine falsche Zahl halluzinieren, kann das Skript dies nicht erkennen.

#### Beispiel 2: Agentic KI – Nutzung eines Websuchwerkzeugs

Jetzt erstellen wir einen Agenten, der entscheiden kann, wann er das Web durchsuchen soll, um aktuelle Informationen zu beschaffen. Dieser Agent nutzt das DuckDuckGo‑Werkzeug, um Live‑Daten abzurufen.

# agentic_example.py
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, Tool
from langchain_community.tools import DuckDuckGoSearchRun
import os

load_dotenv()

# 1. LLM definieren
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# 2. Suchwerkzeug definieren
search_tool = DuckDuckGoSearchRun()

# 3. Werkzeug in LangChains Tool‑Format verpacken
tools = [
    Tool(
        name="web_search",
        func=search_tool.run,
        description="Nützlich zur Beantwortung von Fragen zu aktuellen Ereignissen oder Echtzeitinformationen."
    )
]

# 4. Agent mit Zero‑Shot‑React‑Strategie erstellen (das LLM denkt nach, bevor es handelt)
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent="zero-shot-react-description",
    verbose=True,  # zeigt die Gedankengänge und Aktionen des Agenten
    handle_parsing_errors=True
)

# 5. Eine Frage stellen, die aktuelle Daten erfordert
query = "Wie hoch ist die aktuelle Einwohnerzahl von Paris laut den neuesten Daten?"
result = agent.run(query)
print("\nEndgültige Antwort:\n", result)

Wenn du dieses Skript ausführst, siehst du die internen Überlegungen des Agenten. Es könnte etwa Folgendes ausgeben:

> **Thought:** Ich muss die aktuelle Einwohnerzahl von Paris herausfinden. Ich sollte das Web durchsuchen. > **Action:** web_search > **Action Input:** "Paris Bevölkerung 2025" > **Observation:** [ein Auszug aus einer aktuellen Volkszählung oder Wikipedia] > **Thought:** Ich kenne jetzt die Antwort. > **Final Answer:** Nach den neuesten Daten (Mitte 2024) beträgt die Einwohnerzahl von Paris etwa 2,1 Millionen.

Der entscheidende Unterschied? Der Agent hat aktiv externe Informationen abgerufen, sie bewertet und eine fundierte Antwort geliefert. Wäre das erste Suchergebnis veraltet, könnte er sich entscheiden, die Anfrage zu verfeinern.

#### Beispiel 3: Mehrschrittiger Agent (Planung)

Lass uns den Agenten noch weiter treiben. Wir geben ihm ein Ziel, das mehrere Teilaufgaben erfordert: Finde die Einwohnerzahl von Paris, berechne die Bevölkerungsdichte und vergleiche sie mit einer anderen Stadt.

# multi_step_agent.py
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, Tool
from langchain_community.tools import DuckDuckGoSearchRun
import os

load_dotenv()

llm = ChatOpenAI(model="gpt-4o", temperature=0)
search = DuckDuckGoSearchRun()

tools = [
    Tool(name="web_search", func=search.run,
         description="Suche nach aktuellen Informationen im Web.")
]

agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True)

query = (
    "Finde die aktuelle Einwohnerzahl von Paris, Frankreich. "
    "Finde dann die Fläche von Paris (in Quadratkilometern). "
    "Berechne die Bevölkerungsdichte (Personen pro km²). "
    "Vergleiche diese Dichte abschließend mit der von Tokio."
)

result = agent.run(query)
print(result)

Der Agent führt eine Reihe von Schritten aus: Suche nach Einwohnerzahl, Suche nach Fläche, Berechnung der Dichte (er kann ein Rechnertool verwenden, falls verfügbar – LangChain unterstützt Rechenwerkzeuge), Suche nach Tokios Dichte und Synthese des Vergleichs. Im ausführlichen Modus kannst du den Gedankengang verfolgen.

Wichtige Erkenntnisse aus den Beispielen

• **Generative KI** antwortet direkt, kann aber keine Daten verifizieren oder neue beschaffen. Sie verlässt sich ausschließlich auf ihre Trainingsdaten, die möglicherweise veraltet sind.
• **Agentic KI** kann Werkzeuge nutzen, um Echtzeitinformationen zu beschaffen, komplexe Anfragen zu zerlegen und zu iterieren. Dadurch ist sie für Aufgaben, die Genauigkeit, Aktualität oder mehrschrittiges Denken erfordern, weitaus zuverlässiger.

Praktische Überlegungen beim Bau von Agenten

1. **Werkzeugsicherheit** – Gewähre Agenten nur Zugriff auf Werkzeuge, denen du vertraust. Ein böswilliger Prompt könnte einen Agenten dazu bringen, Dateien zu löschen oder gefährliche Befehle auszuführen. 2. **Kosten** – Agentenschleifen rufen das LLM mehrfach auf, was den Token‑Verbrauch erhöht. Überwache deine API‑Rechnungen. 3. **Fehlerbehandlung** – Agenten können in Endlosschleifen geraten oder Werkzeugausgaben falsch interpretieren. Verwende `handle_parsing_errors=True` und setze `max_iterations`. 4. **Gedächtnis** – Für länger laufende Aufgaben integriere ein Speichermodul (z. B. `ConversationBufferMemory`), damit der Agent sich an vorherige Schritte erinnert.

Der Weg nach vorne

Die Branche investiert massiv in agentische Systeme. Der KI‑Blog von NVIDIA untersucht, wie Agenten mit Simulationen interagieren können, Microsofts Copilot‑Agenten automatisieren Arbeitsabläufe, und Anthropic hat werkzeugbasierte Aktionen in ihren Modellen demonstriert. OpenAIs Assistants API bietet einen integrierten Code‑Interpreter, Abruf und Funktionsaufrufe – alles Kernkomponenten eines Agenten.

In naher Zukunft werden wir Agenten sehen, die:

• Reiserouten buchen, indem sie APIs von Fluggesellschaften aufrufen.
• Kalender verwalten und E‑Mails versenden.
• Code autonom schreiben und bereitstellen.
• Wissenschaftliche Forschung betreiben, indem sie Datenbanken abfragen.

Generative KI wird die grundlegende Schicht bleiben – das „Gehirn“. Aber den „Körper“ – die Fähigkeit, autonom zu handeln – liefert die Agentic KI.

Fazit

Generative KI und Agentic KI repräsentieren zwei Stufen maschineller Intelligenz. Erstere ist ein leistungsstarker Inhaltsgenerator; letztere ist ein autonomer Ausführer. Agentic KI erweitert die Fähigkeiten generativer Modelle um Planung, Werkzeugnutzung und Gedächtnis. Als Entwickler können wir bereits mit wenigen Zeilen Python und Open‑Source‑Frameworks wie LangChain funktionsfähige Agenten bauen.

Die Beispiele in diesem Artikel zeigen ein klares Muster: Für einfache, geschlossene Fragen genügt ein einfaches LLM. Für Aufgaben, die aktuelle Daten, mehrschrittiges Denken oder externe Aktionen erfordern, ist ein Agent unverzichtbar. Der Aufstieg autonomer Agenten ist nicht nur ein Trend – er ist der natürliche nächste Schritt, um KI in realen Arbeitsabläufen wirklich nützlich zu machen.