Die Evolution: LLM zum Agenten

Ein LLM ist ein Gehirn. Ein Agent ist ein Gehirn mit Haenden.

LLM (2022-2023):

Sie: "How do I fix this bug?"
LLM: "Here's how to fix it: [explanation]"
Sie: *wendet den Fix manuell an*

Agent (2025-2026):

Sie: "Fix this bug"
Agent: *liest den Code*
       *identifiziert den Bug*
       *schreibt den Fix*
       *fuehrt die Tests aus*
       *behebt die Testfehler*
       *committet das Ergebnis*
Sie: *reviewed den PR*

Der entscheidende Unterschied: Agenten handeln in der realen Welt. Sie generieren nicht nur Text -- sie lesen Dateien, rufen APIs auf, fuehren Befehle aus und modifizieren Systeme.

Was macht etwas "agentisch"?

Ein KI-System ist agentisch, wenn es diese vier Eigenschaften hat:

1. Tool-Nutzung -- Es kann mit externen Systemen interagieren

Tools: Dateisystem, APIs, Datenbanken, Browser, Terminals

2. Autonomie -- Es entscheidet selbst, was als Naechstes zu tun ist, ohne Schritt-fuer-Schritt-Anweisungen

"Deploy this feature" -> plant Schritte, fuehrt sie aus, behandelt Fehler

3. Feedback-Schleifen -- Es beobachtet das Ergebnis seiner Aktionen und passt sich an

Tests ausfuehren -> 3 Fehler -> Fehler lesen -> Code fixen -> erneut ausfuehren -> bestanden

4. Zielorientiert -- Es arbeitet auf ein Ziel hin, nicht nur auf eine einzelne Antwort

Ziel: "Make this codebase production-ready"
-> Mehrere Schritte ueber Minuten oder Stunden

Wenn es nur Fragen beantwortet, ist es ein Chatbot. Wenn es Aktionen ausfuehrt, um Ziele zu erreichen, ist es ein Agent.

Single-Agent vs. Multi-Agent

Einzelner Agent -- eine KI erledigt alles:

Nutzer -> [Agent] -> liest Code, schreibt Code, fuehrt Tests aus, deployed

• Einfache Architektur
• Funktioniert gut fuer fokussierte Aufgaben
• Begrenzt durch die Faehigkeiten eines einzelnen Modells

Multi-Agent -- spezialisierte Agenten arbeiten zusammen:

Nutzer -> [Planer-Agent] -> zerlegt Aufgabe in Teilaufgaben
           |-> [Coder-Agent]     -> schreibt Implementierung
           |-> [Reviewer-Agent]  -> prueft Code-Qualitaet
           +-> [Test-Agent]      -> schreibt und fuehrt Tests aus

• Jeder Agent spezialisiert sich auf seine Rolle
• Kann verschiedene Modelle pro Agent nutzen (guenstig fuer Planung, teuer fuer Coding)
• Komplexer, aber bewaeltigt groessere Aufgaben

Frontend- vs. Backend-Agenten

Wo der Agent laeuft, ist wichtig:

Frontend-Agenten (nutzerorientiert):

• Laufen in der Umgebung des Nutzers (IDE, Browser, Terminal)
• Nutzer sieht und kontrolliert die Aktionen des Agenten
• Beispiele: Claude Code, Cursor, OpenCode
• Vertrauen: Nutzer kann jede Aktion genehmigen/ablehnen
• Latenz: interaktiv, Echtzeit-Feedback

Backend-Agenten (headless):

• Laufen auf Servern ohne Nutzerinteraktion
• Ausgeloest durch Events (neues Ticket, Alert, Zeitplan)
• Beispiele: CI/CD-Bots, Monitoring-Agenten, Chatbots
• Vertrauen: vorkonfigurierte Regeln und Leitplanken
• Latenz: koennen stundenlang autonom laufen

Hybrid:

• Backend-Agent verarbeitet die Aufgabe
• Frontend benachrichtigt Nutzer bei kritischen Entscheidungen
• Beispiel: Agent reviewed PR, postet Kommentare, aber Mensch merged

MCP -- Das Model Context Protocol

MCP standardisiert, wie Agenten sich mit Tools verbinden:

Ohne MCP:
  Jeder Agent x jedes Tool = individuelle Integration
  10 Agenten x 20 Tools = 200 Integrationen

Mit MCP:
  Jeder Agent spricht MCP -> Jedes Tool spricht MCP
  10 Agenten x 1 Protokoll x 20 Tools = 30 Integrationen

MCP-Architektur:

+------------+     MCP      +----------------+
|  Agent     |<------------>|  MCP Server    |
|  (Client)  |              |  (Tool)        |
+------------+              +----------------+
                            Beispiele:
                            - Dateisystem
                            - GitHub
                            - Datenbank
                            - Browser
                            - Slack
                            - Jira

Was MCP bietet:

• Standardprotokoll fuer Tool-Erkennung und -Aufruf
• Ressourcenzugriff (Dateien, Daten)
• Prompt-Vorlagen
• Sampling (Agent-zu-Agent-Kommunikation)

MCP ist fuer Agenten das, was HTTP fuer Webbrowser ist -- ein universelles Protokoll, das jedem Agenten erlaubt, jedes Tool zu nutzen.

Die Agenten-Landschaft 2026

Wichtige agentische KI-Systeme:

Agent	Domaene	Typ	Hauptmerkmal
Claude Code	Coding	Frontend CLI	Volle Autonomie, selbstkorrigierend
OpenCode	Coding	Frontend CLI	Open-Source, MCP-nativ
Cursor	Coding	Frontend IDE	KI-first Editor
Devin	Coding	Backend	Autonomer Softwareentwickler
Operator	Browser	Frontend	Web-Automatisierung
AutoGPT	Allgemein	Backend	Aufgabenzerlegung
CrewAI	Multi-Agent	Framework	Agenten-Orchestrierung

Der Trend: Jede Software-Kategorie bekommt eine agentische Version. E-Mail-Agenten, Datenanalyse-Agenten, Kundensupport-Agenten -- wenn Menschen es heute tun, wird ein Agent es morgen erweitern.

---quiz question: Was ist der entscheidende Unterschied zwischen einem LLM und einem KI-Agenten? options:

• { text: "Agenten sind schneller als LLMs", correct: false }
• { text: "Agenten handeln in der realen Welt -- lesen Dateien, rufen APIs auf, fuehren Befehle aus -- statt nur Text zu generieren", correct: true }
• { text: "Agenten verwenden eine andere Art von neuronalem Netzwerk", correct: false } feedback: Ein LLM generiert Textantworten. Ein Agent nutzt ein LLM als sein "Gehirn", fuegt aber die Faehigkeit hinzu, reale Aktionen auszufuehren -- Dateien lesen, Code schreiben, Befehle ausfuehren, APIs aufrufen -- und schafft so Feedback-Schleifen, die komplexe Ziele erreichen.

---quiz question: Was standardisiert MCP (Model Context Protocol)? options:

• { text: "Wie KI-Modelle trainiert werden", correct: false }
• { text: "Wie Agenten sich mit externen Tools verbinden und diese nutzen", correct: true }
• { text: "Wie Nutzer sich bei KI-Diensten authentifizieren", correct: false } feedback: MCP ist ein universelles Protokoll fuer die Agent-Tool-Kommunikation. Statt individuelle Integrationen fuer jede Agent-Tool-Kombination zu bauen, bietet MCP eine Standard-Schnittstelle -- und reduziert den Integrationsaufwand von N*M auf N+M.

---quiz question: Wann wuerden Sie eine Multi-Agent-Architektur gegenueber einem einzelnen Agenten bevorzugen? options:

• { text: "Immer -- Multi-Agent ist immer besser", correct: false }
• { text: "Wenn die Aufgabe mehrere Spezialisierungen erfordert und Sie verschiedene Modelle fuer verschiedene Teilaufgaben nutzen moechten", correct: true }
• { text: "Nur bei der Arbeit mit Open-Source-Modellen", correct: false } feedback: Multi-Agent-Architekturen glaenzen, wenn verschiedene Teile einer Aufgabe unterschiedliche Expertise erfordern -- ein guenstiges Modell fuer Planung, ein teures fuer Coding, ein schnelles fuer Tests. Fuer fokussierte Aufgaben ist ein einzelner Agent einfacher und ausreichend.