Agentische KI vs. Generative KI: Die neue Grenze autonomer Intelligenz

KI-Agenten vs. Generative KI: Die neue Grenze der autonomen Intelligenz

Künstliche Intelligenz hat sich in den letzten Jahren in zwei unterschiedliche, aber komplementäre Richtungen entwickelt. Auf der einen Seite erzeugt generative KI Texte, Bilder, Code und Audio mit verblüffender Sprachgewandtheit. Auf der anderen Seite geht agentische KI über die Generierung hinaus, um eigenständig zu handeln, Ziele zu setzen und komplexe Arbeitsabläufe zu orchestrieren. Dieser Artikel untersucht die Unterschiede zwischen diesen beiden Paradigmen, erklärt, warum agentische KI den nächsten Schritt in der autonomen Intelligenz darstellt, und bietet einen praktischen Leitfaden zum Bau Ihres ersten agentischen Systems.

Der Wandel von passiver Generierung zu aktivem Handeln wird maßgeblich von führenden KI-Organisationen vorangetrieben. Der NVIDIA AI Blog diskutiert regelmäßig agentische Architekturen, die große Sprachmodelle mit Planung und Werkzeugnutzung kombinieren. Der OpenAI-News-Bereich betont die Entwicklung hin zu Modellen, die iterativ denken und handeln können. Der Microsoft AI Blog berichtet, wie agentische Muster in Produktivitätstools für Unternehmen integriert werden. Der Anthropic-News-Bereich hebt die Sicherheitsforschung für autonome Systeme hervor. Zusammengenommen zeichnen diese Quellen das Bild einer Branche, die sich entschlossen auf Agenten zubewegt, die handeln, nicht nur sprechen.

Den Wandel von generativer zu agentischer KI verstehen

Generative KI zeichnet sich dadurch aus, dass sie auf der Grundlage einer Eingabeaufforderung neue Inhalte erstellt. Ein generatives Modell wie GPT‑4 oder Claude kann einen Aufsatz schreiben, ein Bild erzeugen oder ein Dokument übersetzen. Es erzeugt eine einzelne Ausgabe (oder einen Token-Strom) und wartet dann auf die nächste Eingabe. Seine Intelligenz ist **reaktiv**.

Agentische KI ist dagegen **proaktiv**. Ein agentisches System kann ein übergeordnetes Ziel in Teilaufgaben zerlegen, entscheiden, welche Werkzeuge es aufruft (z. B. eine Suchmaschine, einen Taschenrechner, eine API), Zwischenergebnisse auswerten und die Schleife wiederholen, bis das Ziel erreicht ist. Es führt einen internen Zustand, merkt sich vergangene Schritte und passt seinen Plan an, wenn etwas fehlschlägt. Diese Autonomie macht agentische KI zu einer neuen Grenze.

Die Unterscheidung ist nicht binär. Viele moderne generative Modelle können mit einem agentischen Framework (wie LangChain, AutoGPT oder Microsoft Semantic Kernel) umhüllt werden, um sie in Agenten zu verwandeln. Das generative Modell wird zum „Gehirn“; das agentische Framework bietet den „Körper“ – Gedächtnis, Werkzeugzugriff und Planungsschleifen.

Kernfähigkeiten agentischer KI

Agentische Systeme stützen sich typischerweise auf mehrere Schlüsselkomponenten:

• **Aufgabenzerlegung** – Der Agent zerlegt ein komplexes Ziel in kleinere, handhabbare Schritte.
• **Werkzeugnutzung** – Der Agent kann externe Funktionen aufrufen, wie Websuche, Codeausführung oder Datenbankabfragen.
• **Gedächtnis** – Kurzzeitgedächtnis (aktueller Gesprächskontext) und Langzeitgedächtnis (vergangene Sitzungen oder abgerufenes Wissen).
• **Selbstreflexion** – Der Agent bewertet seine eigenen Ausgaben, erkennt Fehler und wiederholt Vorgänge.
• **Planung und Neuplanung** – Der Agent erstellt einen anfänglichen Plan, passt ihn aber basierend auf Rückmeldungen an.

Allein mit generativer KI ist nichts davon möglich; es wird eine Orchestrierungsschicht benötigt. Agentische KI liefert diese Schicht.

Voraussetzungen

Bevor Sie einen einfachen Agenten bauen, stellen Sie sicher, dass Ihre Umgebung diese Anforderungen erfüllt:

• **Betriebssystem**: Linux, macOS oder Windows (WSL für Windows empfohlen)
• **Python**: 3.10 oder höher
• **Paketmanager**: pip (pip3 auf manchen Systemen)
• **API-Schlüssel**: Ein API-Schlüssel eines generativen KI-Anbieters (z. B. OpenAI, Anthropic oder ein lokales Modell via Ollama)
• **Speicherplatz**: Mindestens 500 MB für Bibliotheken und Beispiele

Die Beispiele unten verwenden die OpenAI-API aufgrund ihrer weiten Verbreitung, aber das Muster ist anbieterunabhängig.

Schritt-für-Schritt-Installation

Wir installieren LangChain – eines der beliebtesten Frameworks zum Bau agentischer KI – zusammen mit seinen Community-Tools und der OpenAI-Integration.

1. Virtuelle Python-Umgebung erstellen und aktivieren

Das Isolieren von Abhängigkeiten vermeidet Versionskonflikte mit anderen Projekten.

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

2. pip aktualisieren und Kernpakete installieren

Aktualisieren Sie zuerst pip, um Warnungen zu vermeiden, installieren Sie dann LangChain, seine CLI und die OpenAI-Integration.

pip install --upgrade pip
pip install langchain langchain-cli langchain-openai

3. Zusätzliche Werkzeugintegrationen installieren

Agenten benötigen konkrete Werkzeuge. Wir installieren ein einfaches Rechenwerkzeug und ein Websuchwerkzeug (DuckDuckGo, das keinen API-Schlüssel benötigt).

pip install langchain-community duckduckgo-search

4. OpenAI-API-Schlüssel als Umgebungsvariable setzen

So bleibt der Schlüssel außerhalb Ihres Codes. Ersetzen Sie `sk-...` durch Ihren tatsächlichen Schlüssel.

export OPENAI_API_KEY="sk-ihr-tatsächlicher-schlüssel-hier"

Unter Windows (Eingabeaufforderung):

set OPENAI_API_KEY=sk-ihr-tatsächlicher-schlüssel-hier

5. Installation überprüfen

Führen Sie einen kurzen Test durch, um sicherzustellen, dass LangChain die API sieht.

python -c "from langchain_openai import ChatOpenAI; llm = ChatOpenAI(model='gpt-4o-mini'); print(llm.invoke('Hello'))"

Wenn Sie eine Antwort sehen (die Begrüßung des Modells), ist alles bereit.

Anwendungsbeispiele

Wir erstellen nun einen einfachen Agenten, der Fragen beantworten kann, indem er Berechnungen durchführt und das Web durchsucht. Der Agent verwendet das generative Modell (GPT‑4o‑mini) als Denkmaschine und zwei Werkzeuge: ein Rechenwerkzeug und ein DuckDuckGo-Suchwerkzeug.

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

from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain.tools import Tool
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai import ChatOpenAI

# 1. Sprachmodell einrichten
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# 2. Werkzeuge definieren
def multiply(a: float, b: float) -> float:
    """Multipliziert zwei Zahlen."""
    return a * b

def add(a: float, b: float) -> float:
    """Addiert zwei Zahlen."""
    return a + b

search = DuckDuckGoSearchRun()

tools = [
    Tool(name="Taschenrechner", func=lambda x: eval(x), description="Nützlich für Arithmetik. Eingabe muss ein Python-Ausdruck sein."),
    Tool(name="Websuche", func=search.run, description="Durchsucht das Web nach aktuellen Informationen."),
]

# 3. Prompt-Vorlage erstellen
prompt = ChatPromptTemplate.from_messages([
    ("system", "Sie sind ein hilfsbereiter Assistent, der Werkzeuge nutzen kann, um Fragen zu beantworten."),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# 4. Agent bauen
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# 5. Abfragen ausführen
response = agent_executor.invoke({"input": "Was ist 12345 * 67890? Suche dann nach der Bevölkerungszahl Japans."})
print(response["output"])

Führen Sie das Skript aus:

python simple_agent.py

Die Ausgabe (mit `verbose=True`) zeigt die Gedankenkette des Agenten:

• Zuerst entscheidet er sich, das Rechenwerkzeug mit dem Ausdruck `12345 * 67890` zu verwenden.
• Nach Erhalt des Ergebnisses (838.102.050) ruft er dann die Websuche mit „Bevölkerungszahl Japans“ auf.
• Schließlich kombiniert er beide Antworten zu einer einzigen Ausgabe.

Erklärung der Schlüsselelemente

• **`create_openai_functions_agent`**: Nutzt die Funktionsaufruffähigkeit von OpenAI, damit das Modell entscheiden kann, welches Werkzeug aufgerufen werden soll.
• **`AgentExecutor`**: Umhüllt den Agenten und übernimmt die Schleife: Beobachtung → Gedanke → Aktion → Beobachtung.
• **Werkzeuge**: Jedes Werkzeug hat einen `name`, eine `func` und eine `description`. Das Modell verwendet die Beschreibung, um zu entscheiden, welches Werkzeug zur Anfrage des Benutzers passt.
• **`agent_scratchpad`**: Ein Platzhalter, den der Executor mit Zwischenschritten (Gedanken und Werkzeugausgaben) füllt, damit das Modell darauf zurückgreifen kann.

Anpassung an andere Anbieter

Wenn Sie ein lokales Modell bevorzugen (z. B. via Ollama), ersetzen Sie die LLM-Definition durch:

from langchain_ollama import ChatOllama
llm = ChatOllama(model="llama3.2", temperature=0)

Das gleiche agentische Muster funktioniert, obwohl kleinere Modelle möglicherweise einfachere Prompts und weniger Werkzeuge erfordern.

Über die Grundlagen hinaus: Autonomie erweitern

Das obige Beispiel zeigt einen reaktiven Agenten – er handelt nur, wenn ihm eine Eingabe gegeben wird. Ein echter **autonomer Agent** läuft in einer Schleife und entscheidet kontinuierlich, was als Nächstes zu tun ist. Sie können hinzufügen:

• **Gedächtnis**: Verwenden Sie `ConversationBufferMemory` oder `PersistentMemory`, damit sich der Agent über Sitzungen hinweg an den Kontext erinnert.
• **Neuplanung**: Bewerten Sie nach jedem Schritt, ob der ursprüngliche Plan noch gültig ist.
• **Fehlerbehandlung**: Wenn ein Werkzeug fehlschlägt, kann der Agent eine Alternative versuchen oder um Klarstellung bitten.

Ein fortgeschritteneres Muster ist die **ReAct**-Schleife (Reason + Act), die bereits in LangChains `AgentExecutor` integriert ist. Das obige Beispiel verwendet ReAct implizit.

Der Weg nach vorn

Generative KI hat uns eine revolutionäre neue Art der Inhaltserstellung beschert. Agentische KI gibt uns eine Möglichkeit, Verhalten zu erzeugen. Die Kombination von generativen Modellen mit Orchestrierungs-Frameworks verwandelt statische APIs in dynamische Mitarbeiter.

Wie der NVIDIA AI Blog betont, ist das Training von Modellen für offene Umgebungen ein aktives Forschungsgebiet. Die OpenAI-News heben Fortschritte im logischen Denken der Modelle hervor, was direkt die Zuverlässigkeit von Agenten verbessert. Der Microsoft AI Blog zeigt praktische Einsätze von Agenten in Microsoft Copilot und Azure AI. Die Anthropic-News konzentrieren sich auf die Sicherheitsherausforderungen autonomer Systeme und erinnern uns daran, dass mit Handlungsfähigkeit Verantwortung einhergeht.

In naher Zukunft können wir erwarten, dass Agenten ganze Arbeitsabläufe verwalten: Termine planen, Code schreiben und bereitstellen, Recherchen durchführen und sogar mit anderen Agenten verhandeln. Die Grenze zwischen generativer und agentischer KI wird verschwimmen, da Modelle besser planen und sich selbst korrigieren können.

Für Entwickler ist der Einstieg bereits jetzt möglich. Mit ein paar Zeilen Python und einem API-Schlüssel können Sie einen Agenten bauen, der mehr tut als nur reden – er handelt. Die neue Grenze der autonomen Intelligenz ist kein fernes Traumbild; sie ist eine Bibliotheksinstallation entfernt.

Beginnen Sie noch heute mit Experimenten und sehen Sie zu, wie Ihre KI von Worten zu Taten übergeht.