Agentische KI vs. generative KI: Wie autonome Agenten intelligente Workflows neu definieren

Agentische KI vs. Generative KI: Wie autonome Agenten intelligente Arbeitsabläufe neu definieren

Künstliche Intelligenz hat eine Schwelle überschritten. Jahre lang konzentrierte sich die Branche darauf, Modelle zu entwickeln, die Texte, Bilder und Code mit erstaunlicher Flüssigkeit erzeugen können. Generative KI wurde zu einem geläufigen Begriff und versorgte Chatbots und kreative Tools, die auf Aufforderungen mit menschenähnlichen Ausgaben reagieren. Doch eine neue Welle der KI verwandelt diese Fähigkeiten in etwas weitaus Praktischeres: Handlung.

Dies ist die Ära der agentischen KI. Anstatt nur Fragen zu beantworten, interpretieren agentische Systeme Ziele, zerlegen sie in Schritte, nutzen Werkzeuge und führen Aufgaben mit minimaler menschlicher Beteiligung aus. Der Wandel von der Erzeugung einer Antwort zur Erledigung einer Aufgabe verändert, wie Unternehmen Arbeitsabläufe automatisieren. In diesem Artikel vergleichen wir generative KI und agentische KI, erklären, warum autonome Agenten wichtig sind, und gehen ein konkretes technisches Beispiel durch, damit Sie noch heute einen einfachen Agenten bauen können.

Generative KI: Das Fundament

Generative KI bezieht sich auf Machine-Learning-Modelle, die neue Inhalte erzeugen – Text, Code, Bilder, Audio oder Video – basierend auf Mustern, die aus massiven Datensätzen gelernt wurden. Große Sprachmodelle (Large Language Models, LLMs) wie die GPT-Serie von OpenAI und Claude von Anthropic sind die bekanntesten Beispiele. Ihre charakteristische Eigenschaft ist die Fähigkeit, eine natürlichsprachliche Anweisung entgegenzunehmen und eine kohärente, kontextrelevante Ausgabe zu liefern.

Der NVIDIA AI Blog hat ausführlich darüber berichtet, wie generative KI-Modelle mithilfe von Transformatoren und beschleunigtem Rechnen trainiert werden. Diese Modelle lernen statistische Muster aus Billionen von Tokens und werden zu Zusammenfassungen, Übersetzungen, Schlussfolgerungen und Programmierassistenz fähig. Die Neuigkeiten von OpenAI heben regelmäßig Verbesserungen der Modellfähigkeiten hervor, von längeren Kontextfenstern bis hin zu besserer Befolgung von Anweisungen. Der Microsoft AI Blog wiederum hat dokumentiert, wie generative KI in Produkte wie Microsoft 365 Copilot integriert wird und so aus reiner Modellleistung benutzerorientierte Produktivitätstools macht.

Generative KI glänzt in einem einzelnen Schritt: das richtige nächste Token (oder Pixel oder Audio-Frame) basierend auf einer Eingabe vorherzusagen. Sie ist reaktiv, nicht proaktiv. Wenn Sie sie bitten, eine E-Mail zu entwerfen, entwirft sie die E-Mail. Wenn Sie sie bitten, ein Skript zu debuggen, liefert sie ein korrigiertes Skript. Aber sie tut *nichts* über die Antwort hinaus. Sie kann keine Datenbank abfragen, es sei denn, jemand holt die Daten zuerst. Sie kann keinen Code auf einem Server bereitstellen, es sei denn, ein externer Prozess löst diese Bereitstellung aus. Diese Einschränkung ist genau das, was agentische KI adressiert.

Agentische KI: Von der Vorhersage zum Handeln

Agentische KI beschreibt Systeme, die Foundation-Modelle als ihre Denk-Engine nutzen, sie jedoch in eine Schleife aus Wahrnehmung, Planung und Handlung einbetten. Ein Agent erhält ein übergeordnetes Ziel, interpretiert es, zerlegt es in Teilaufgaben, wählt geeignete Werkzeuge aus (APIs, Code-Interpreter, Websuche, Dateisysteme), führt diese Werkzeuge aus, beobachtet die Ergebnisse und iteriert, bis das Ziel erreicht ist.

Der Nachrichtenbereich von Anthropic hat hervorgehoben, wie sich KI-Assistenten von passiven Antwortern zu aktiven Kollaborateuren entwickeln, die Computer nutzen, langlaufende Aufgaben verwalten und Kontrolle über mehrere Schritte hinweg weitergeben können. Der Microsoft AI Blog hat Agent-Frameworks beschrieben, in denen Copilot-Erlebnisse durch autonome Arbeitsabläufe erweitert werden. Diese Agenten sind keine eigene Art von Modell; sie sind eine architektonische Schicht über generativen Modellen.

Der Unterschied ist subtil, aber entscheidend. Generative KI fragt: *Was ist das wahrscheinlichste nächste Wort?* Agentische KI fragt: *Was ist die nächste Aktion, die mich dem Ziel näher bringt?*

![Vergleich nicht verfügbar] — Aber konzeptionell stellen Sie sich zwei Mitarbeiter vor. Einer ist ein brillanter Analytiker, der jede Frage beantworten kann, aber nie seinen Schreibtisch verlässt. Der andere ist ein Projektmanager, der vielleicht nicht alles weiß, aber plant, delegiert, den Fortschritt prüft und liefert. Generative KI ist der Analytiker. Agentische KI ist der Manager mit dem Analytiker in Bereitschaft.

Hauptunterschiede zwischen agentischer und generativer KI

| Dimension | Generative KI | Agentische KI | | --- | --- | --- | | **Kernfunktion** | Erzeugt Inhalte (Text, Code, Bilder) | Führt mehrstufige Arbeitsabläufe aus | | **Interaktionsmodell** | Aufforderung → Antwort | Ziel → Plan → Handeln → Beobachten → Iterieren | | **Gedächtnis** | Zustandslos (oder begrenzter Kontext) | Interner Zustand, Reflexion, Werkzeugverlauf | | **Werkzeugnutzung** | Standardmäßig keine | API-Aufrufe, Dateisystemzugriff, Codeausführung | | **Menschliche Beteiligung** | Jede Aufforderung ist eine explizite Anweisung | Nur übergeordnetes Ziel; Agent korrigiert sich selbst | | **Fehlerart** | Plausible, aber falsche Ausgabe | Falsche Handlungskette oder Endlosschleife | | **Beispiel** | ChatGPT schreibt einen Bericht | Ein Agent, der den Bericht recherchiert, schreibt und per E-Mail versendet |

Generative KI bleibt die Engine innerhalb agentischer Systeme. Tatsächlich sind die agentischen Modelle auf dem Markt oft dieselben LLMs plus Orchestrierung. Das Neue ist nicht das Modell; es ist die Kontrollschleife.

Wie autonome Agenten Arbeitsabläufe neu definieren

Das Versprechen agentischer KI ist nicht nur Bequemlichkeit. Es ist die Automatisierung von *Urteilsvermögen* – der Teil der Büroarbeit, der darin besteht, zu entscheiden, was als Nächstes zu tun ist.

1. Von Widgets zu Arbeitsabläufen

Traditionelle Automatisierung basiert auf fest codierten Sequenzen. Ein Skript extrahiert eine Datei, transformiert sie, lädt sie. Wenn ein Feld fehlt, stürzt das Skript ab oder verhält sich falsch. Ein Agent hingegen kann darüber nachdenken, wie die Daten aussehen, alternative Extraktionsmethoden wählen und sich von Anomalien erholen. Er verwandelt fragile Pipelines in adaptive.

2. Von Chatbots zu Kollegen

Generative KI-Chatbots werden oft wie Suchmaschinen ohne die Suche behandelt. Benutzer fragen, erhalten und kopieren-einfügen in andere Tools. Agenten eliminieren diesen Kontextwechsel. Ein Agent kann das Ziel erhalten: „Finde alle offenen Rechnungen über 10.000 $, entwirf Erinnerungs-E-Mails und plane ein Folgegespräch.“ Er koordiniert zwischen der Finanz-API, dem E-Mail-Client und dem Kalendersystem. Der Mensch prüft am Ende, anstatt bei jedem Schritt mitzuwirken.

3. Von zustandslosem zu zustandsbehaftetem Denken

Ein wesentlicher Unterschied in agentischen Systemen ist das Konzept des Gedächtnisses über Tool-Aufrufe hinweg. Die Architektur führt eine Liste von Beobachtungen, Entscheidungen und Teilergebnissen. Dies ermöglicht Chain-of-Thought-Reasoning, das über eine einzelne Aufforderung hinaus Bestand hat. Der Agent kann sagen: „Ich habe Methode A versucht, aber die API hat einen Fehler zurückgegeben. Ich wechsle zu Methode B und protokolliere die Abweichung.“ In dieser Selbstreflexion entsteht die eigentliche Fähigkeit.

4. Reifung des Ökosystems

Sowohl der Microsoft AI Blog als auch der NVIDIA AI Blog beschreiben die rasche Ausweitung von Agent-Frameworks: Semantic Kernels, Retrieval-Augmented-Generation-Pipelines und Orchestrierungsdienste, die Tool-Aufrufe, Wiederholungen und Token-Budgets verwalten. Die Nachrichten von Anthropic haben behandelt, wie Modelle nun darauf trainiert werden, Bildschirme zu verstehen und Computeroberflächen direkt zu bedienen, was die Grenze zwischen API-Integration und universeller Benutzeroberflächen-Automatisierung verschwimmen lässt.

Die Branche bewegt sich auf eine Zukunft zu, in der Agenten Standard-Infrastrukturkomponenten sind – bereitgestellt, überwacht und verwaltet neben Apps und Datenbanken. Für Entwickler entsteht dadurch die dringende Notwendigkeit zu verstehen, wie man sie baut und bewertet.

Praktisches Tutorial: Einen Recherche-Agenten mit Python bauen

Kommen wir von der Theorie zur Praxis. Wir werden einen kleinen Agenten bauen, der eine Recherche-Frage annimmt, eine Websuche durchführt, Zusammenfassungen aus den Ergebnissen extrahiert und einen strukturierten Bericht erstellt. Er nutzt die OpenAI-API fürs Denken und für Funktionsaufrufe sowie ein einfaches Suchwerkzeug. Dieser Agent ist bewusst minimal gehalten, aber seine Architektur spiegelt das Muster wider, das in Produktionssystemen verwendet wird: eine Schleife, ein Werkzeugregister und ein Modell mit strukturierter Ausgabe.

Voraussetzungen

• Python 3.10 oder neuer
• Ein OpenAI-API-Schlüssel (oder jede kompatible LLM-API)
• `pip` zur Paketinstallation
• Internetzugang für API-Aufrufe

Wir verwenden das `openai` Python SDK, `python-dotenv` für Umgebungsvariablen und `requests`, um eine öffentliche Such-API aufzurufen. Der Einfachheit halber nutze ich den HTML-Endpunkt von DuckDuckGo – kein API-Schlüssel erforderlich – aber Sie können später eine formelle Such-API durch ersetzen.

Schritt-für-Schritt-Installation

Erstellen Sie zunächst eine isolierte virtuelle Umgebung. Dies verhindert Abhängigkeitskonflikte mit anderen Python-Projekten:

python -m venv agent_env

Aktivieren Sie die virtuelle Umgebung. Der Befehl unterscheidet sich je nach Betriebssystem. Unter macOS und Linux führen Sie aus:

source agent_env/bin/activate

Unter Windows führen Sie aus:

agent_env\Scripts\activate

Nun installieren Sie die erforderlichen Pakete. Das Paket `openai` gibt uns Client-Zugriff auf die API, während `python-dotenv` unseren geheimen Schlüssel aus einer lokalen Datei lädt:

pip install openai python-dotenv requests

Erstellen Sie als Nächstes eine `.env`-Datei im Projektstamm. Diese Datei speichert den API-Schlüssel außerhalb des Quellcodes:

echo "OPENAI_API_KEY=your-key-here" > .env

Öffnen Sie die Datei und ersetzen Sie `your-key-here` durch Ihren tatsächlichen Schlüssel von der OpenAI-Plattform. Committen Sie `.env` niemals in die Versionskontrolle. Fügen Sie sie Ihrer `.gitignore` hinzu:

echo ".env" >> .gitignore

Verwendungsbeispiele

Erstellen Sie eine neue Datei namens `research_agent.py`. Wir schreiben den Agenten in drei Teilen: ein Werkzeugregister, eine Denkschleife und einen Hauptprogrammeinstieg.

Importieren Sie zunächst die Bibliotheken und laden Sie die Umgebungsvariablen:

import json
import os
import re
import requests
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI()  # liest OPENAI_API_KEY automatisch

Definieren Sie als Nächstes das Suchwerkzeug. Es fragt die HTML-Suche von DuckDuckGo ab und extrahiert die ersten Ergebnis-Snippets mit einfachem Regex. In der Produktion würden Sie dies durch eine kostenpflichtige Such-API ersetzen, die strukturiertes JSON zurückgibt:

def web_search(query: str, max_results: int = 5) -> list[dict]:
    """Führt eine einfache Websuche durch und gibt die Top-Ergebnisse zurück."""
    url = "https://html.duckduckgo.com/html/"
    params = {"q": query, "ia": "web"}
    headers = {"User-Agent": "Mozilla/5.0"}
    resp = requests.get(url, params=params, headers=headers, timeout=10)
    resp.raise_for_status()

    results = []
    # Ergebnisblöcke mit Regex extrahieren (vereinfacht, nicht produktionsreif)
    for block in re.findall(r'<a rel="nofollow" class="result__a" href="([^"]+)">(.*?)</a>', resp.text):
        link, title = block
        # HTML-Tags aus dem Titel entfernen
        title = re.sub(r'<[^>]+>', '', title)
        results.append({"title": title, "link": link})
        if len(results) >= max_results:
            break

    return results

Nun definieren Sie das Werkzeugregister. Dieses Wörterbuch ordnet einem Funktionsnamen eine Beschreibung und das aufrufbare Python-Objekt zu. Der Agent ruft es basierend auf der Entscheidung des Modells auf:

TOOLS = {
    "web_search": {
        "function": web_search,
        "description": "Suche im Web. Eingabe: eine einfache Suchanfrage als Zeichenkette.",
    }
}

Der Kern des Agenten ist die Denkschleife. Wir rufen das Modell mit einem System-Prompt auf, der erklärt, wie das Werkzeug zu verwenden ist, und analysieren dann die Antwort. Wenn das Modell einen Tool-Aufruf anfordert, führen wir ihn aus, hängen das Ergebnis an den Nachrichtenverlauf an und schleifen erneut. Wenn das Modell eine endgültige Antwort zurückgibt, stoppen wir:

def run_agent(user_goal: str, max_iterations: int = 5):
    messages = [
        {"role": "system", "content": (
            "Du bist ein Recherche-Agent. Du hast Zugriff auf ein web_search-Werkzeug. "
            "Nutze es, um Fakten zu sammeln, und schreibe dann einen prägnanten Abschlussbericht. "
            "Erfinde keine Daten. Wenn die Suche fehlschlägt, sage das."
        )},
        {"role": "user", "content": user_goal},
    ]

    for i in range(max_iterations):
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=[
                {
                    "type": "function",
                    "function": {
                        "name": "web_search",
                        "description": "Suche im Web nach Informationen",
                        "parameters": {
                            "type": "object",
                            "properties": {
                                "query": {"type": "string"}
                            },
                            "required": ["query"],
                        },
                    },
                }
            ],
            tool_choice="auto",
        )

        msg = response.choices[0].message

        # Wenn das Modell ein Werkzeug aufrufen möchte
        if msg.tool_calls:
            for tool_call in msg.tool_calls:
                # Das Query-Argument parsen
                args = json.loads(tool_call.function.arguments)
                query = args["query"]
                print(f"→ Rufe web_search auf für: '{query}'")

                # Die Suche ausführen
                search_results = TOOLS["web_search"]["function"](query)
                serialized_results = json.dumps(search_results, ensure_ascii=False)

                # Die Tool-Aufrufanforderung des Assistenten und das Tool-Ergebnis anhängen
                messages.append({
                    "role": "assistant",
                    "tool_calls": [
                        {
                            "id": tool_call.id,
                            "type": "function",
                            "function": {
                                "name": "web_search",
                                "arguments": tool_call.function.arguments,
                            },
                        }
                    ],
                })
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": serialized_results,
                })

            continue  # erneut schleifen, damit das Modell die Suchergebnisse nutzen kann

        # Wenn keine Tool-Aufrufe, ist dies die endgültige Antwort
        if msg.content:
            return msg.content

    return "Maximale Iterationen erreicht, ohne eine endgültige Antwort zu erhalten."

Zum Schluss der Hauptprogrammeinstieg. Er liest ein Recherche-Ziel von der Befehlszeile und gibt den Abschlussbericht aus:

if __name__ == "__main__":
    goal = input("Was soll ich recherchieren? ")
    report = run_agent(goal)
    print("\n--- ABSCHLUSSBERICHT ---\n")
    print(report)

Führen Sie das Skript aus:

python research_agent.py

Geben Sie auf Aufforderung eine Recherche-Frage ein:

Was soll ich recherchieren? Was sind die neuesten Trends bei agentischer KI laut den großen KI-Anbietern?

Sie werden sehen, wie der Agent das Suchwerkzeug aufruft, Ergebnisse beobachtet und dann einen zusammengefassten Bericht erstellt. In der Ausgabe beachten Sie die Schleife: Das Modell wählt zu suchen, erhält echte Webdaten und erzeugt erst dann seinen endgültigen Text. Das ist das Wesen agentischen Verhaltens – nicht nur eine wahrscheinliche Antwort zu erzeugen, sondern sie in abgerufene, aktuelle Informationen einzubetten und die dafür nötigen Aktionen auszuführen.

#### Das Verhalten beobachten

Wenn Sie die Konsolenausgabe verfolgen, sehen Sie ein wichtiges Detail: Der Agent beantwortet die Frage nicht einfach in einem Durchgang. Er zerlegt das Bedürfnis in eine Suchanfrage, führt die Anfrage aus und synthetisiert dann die Ergebnisse. Wenn Sie den System-Prompt ändern, um mehrere Suchen zu fördern, kann das Modell mehrere Anfragen nacheinander ausgeben – zum Beispiel eine für NVIDIA, eine für Microsoft, eine für Anthropic. Jedes Suchergebnis wird an den Nachrichtenverlauf angehängt, was dem Modell eine Form von Arbeitsgedächtnis verleiht.

Sie können diesen Agenten in verschiedene Richtungen erweitern:

• Fügen Sie weitere Werkzeuge hinzu, wie `calculate`, `send_email` oder `read_file`.
• Fügen Sie einen Zusammenfassungsschritt hinzu, um lange Suchergebnisse zu komprimieren, bevor Sie sie an das Modell zurücksenden.
• Fügen Sie einen Verifikationsschritt hinzu, der das Modell auffordert, seine eigenen Behauptungen durch eine zweite Suche zu überprüfen.
• Persistieren Sie den Nachrichtenverlauf in einer Datenbank für langlaufende Agenten.

Der Weg nach vorn

Die Unterscheidung zwischen generativer KI und agentischer KI ist nicht nur eine Marketing-Verschiebung. Sie repräsentiert eine Änderung dessen, was wir von Software erwarten: nicht nur Antworten, sondern Ergebnisse. Generative KI bleibt das Fundament – eine leistungsstarke, vielseitige Denk-Engine. Agentische KI setzt diese Engine ein, stattet sie mit Werkzeugen, Gedächtnis und der Autonomie aus, mehrstufige Aufgaben auszuführen.

Sowohl große Anbieter als auch das Open-Source-Ökosystem konvergieren auf eine gemeinsame Architektur: ein Modell, eine Schleife, ein Satz von Werkzeugen und eine Richtlinie. Der NVIDIA AI Blog hebt die Recheninfrastruktur hervor, die Agent-Workloads ermöglicht. Der Nachrichtenbereich von OpenAI zeigt, wie sich Modellfähigkeiten in Werkzeugnutzung und Schlussfolgerung verbessern. Der Microsoft AI Blog beschreibt, wie Agenten in unternehmensweite Copilot-Erlebnisse eingewoben werden. Die Nachrichten von Anthropic zeigen Assistenten, die die Fähigkeit erwerben, Computer direkt zu bedienen. Jedes dieser Signale weist auf dieselbe Schlussfolgerung hin: Die nächste Phase der KI ist kein klügerer Chatbot, sondern ein zuverlässiger digitaler Mitarbeiter.

Die praktische Implikation für Entwickler ist einfach. Wenn Sie Anwendungen auf generativer KI aufgebaut haben, haben Sie bereits das meiste, was Sie brauchen. Beginnen Sie mit einem einfachen Agenten wie dem in diesem Tutorial. Fügen Sie ein Werkzeug hinzu. Beobachten Sie, wo der Agent scheitert, und passen Sie den Prompt oder das Werkzeugdesign an. Iterieren Sie. Das ist dieselbe Schleife, die die Agenten selbst verwenden, und es ist der schnellste Weg, zu lernen, wohin sich diese Technologie entwickelt.

Die Zukunft intelligenter Arbeitsabläufe ist kein Modell, das schön antwortet. Es ist ein System, das die Arbeit erledigt – und einen Menschen nur dann unterbricht, wenn wirklich Urteilsvermögen gefragt ist.