Abgrenzung zwischen klassischem maschinellem Lernen und LLM-basierten Agenten. Warum ein großes Sprachmodell allein nicht „lernt" – und welche drei Säulen ein Agenten-System tatsächlich selbstlernend machen.
1. Die Illusion des Lernens
Große Sprachmodelle (LLMs) wie GPT-4, Claude oder Gemini erzeugen den Eindruck, sie würden „lernen". Ein Agent auf Basis eines LLMs beantwortet Fragen, schreibt Code, analysiert Daten. Doch zwischen der Inferenz eines vortrainierten Modells und echtem Lernen liegt ein fundamentaler Unterschied.
"Intelligence is the ability to adapt to change." — Stephen Hawking
Ein LLM verändert seine Gewichte nicht während der Nutzung. Jeder API-Call startet mit demselben Modell – unabhängig davon, wie oft der Agent zuvor eine ähnliche Aufgabe bearbeitet hat. Ohne externe Mechanismen gibt es kein Gedächtnis, keine Anpassung, kein Lernen.
Die zentrale Frage lautet daher nicht: Kann GPT-4 lernen? – sondern: Welche Architektur um ein LLM herum ermöglicht echtes, kontinuierliches Lernen?
2. Klassisches ML vs. LLM-Agenten
❌ Klassisches Supervised Learning: Lernen durch Training
In klassischem maschinellem Lernen bedeutet „Lernen" die Anpassung interner Parameter (Gewichte) durch einen Optimierungsprozess:
Trainingsdaten → Modell → Vorhersage → Loss → Gradient → Gewichts-Update
Dieser Zyklus wiederholt sich über Tausende bis Millionen von Iterationen. Das Ergebnis: Ein Modell, das aus Daten generalisiert. Aber nach dem Training sind die Gewichte eingefroren. Das Modell kann nicht aus neuen Erfahrungen lernen, ohne erneut trainiert zu werden.
| Eigenschaft | Klassisches ML | LLM (Inferenz) |
|---|---|---|
| Gewichts-Updates | ✅ Während Training | ❌ Keine |
| Lernt aus neuen Daten | ✅ Durch Re-Training | ❌ Nur durch Fine-Tuning |
| Echtzeitanpassung | ❌ Nicht vorgesehen | ❌ Nicht inhärent |
| Kontextuelles Wissen | ❌ Begrenzt auf Features | ✅ Via Prompt/Context Window |
✅ LLM-Agent: Lernen durch Architektur
Ein LLM-Agent kann selbstlernend werden – nicht durch Gewichts-Updates, sondern durch eine Feedback-Architektur, die das Modell umgibt:
Aufgabe → Agent (LLM) → Aktion → Umgebung → Feedback → Agent (angepasst)
↑ |
└──────── Gedächtnis ◄─────────────────────┘
Das LLM bleibt identisch. Was sich ändert: der Kontext, die Strategie, das gespeicherte Wissen. Lernen findet nicht im Modell statt, sondern um das Modell herum.
3. Die drei Säulen selbstlernender Agenten
Drei Mechanismen transformieren einen statischen LLM-Agenten in ein selbstlernendes System:
Säule 1: Feedback-Loops
Der Agent erhält strukturiertes Feedback auf seine Aktionen und passt sein Verhalten im nächsten Versuch an.
def feedback_loop(agent, task, environment, max_iterations=5):
"""Iterativer Feedback-Loop: Agent lernt aus Umgebungsfeedback."""
for i in range(max_iterations):
action = agent.generate(task)
result = environment.evaluate(action)
if result.success:
return action, result
task = enrich_with_feedback(task, result.feedback)
return None, result
Das Muster folgt dem Prinzip des Reinforcement Learning (RL): Der Agent wählt eine Aktion, erhält eine Bewertung (Reward) und passt seine Strategie an. Der entscheidende Unterschied zu klassischem RL: Die „Policy" ist kein neuronales Netz mit trainierbaren Gewichten, sondern ein Prompt, der kontextabhängig erweitert wird.
| RL-Konzept | Mapping auf LLM-Agent |
|---|---|
| State | Aktuelle Aufgabe + bisheriger Kontext |
| Action | Generierter Output (Code, Text, Plan) |
| Reward | Bewertung durch Umgebung (Tests, Metriken, Reviewer) |
| Policy | System-Prompt + Strategie + Gedächtnis |
Säule 2: Persistentes Gedächtnis
Ohne Gedächtnis vergisst der Agent jede Erfahrung nach der Session. Persistentes Gedächtnis speichert erfolgreiche Strategien und macht sie bei ähnlichen Aufgaben abrufbar.
def retrieve_relevant_experience(memory_store, current_task, top_k=3):
"""Findet ähnliche vergangene Erfahrungen via semantischer Suche."""
embedding = embed(current_task.description)
similar = memory_store.search(embedding, top_k=top_k)
return [
{
"task": exp.task,
"solution": exp.solution,
"feedback": exp.feedback,
"success": exp.success
}
for exp in similar
]
Zwei Gedächtnistypen spielen zusammen:
| Typ | Inhalt | Speicher | Abruf |
|---|---|---|---|
| Kurzzeit | Aktueller Dialog, letzte Versuche | Context Window | Automatisch (Prompt) |
| Langzeit | Vergangene Episoden, Strategien, Patterns | Vektor-DB (z.B. FAISS) | Semantische Suche |
Das Langzeitgedächtnis implementiert Experience Replay – ein Konzept aus dem Deep Reinforcement Learning (DQN, Mnih et al. 2015). Statt nur aus der aktuellen Episode zu lernen, greift der Agent auf einen Pool vergangener Erfahrungen zurück.
Säule 3: Selbstkritik
Der Agent bewertet seinen eigenen Output, bevor er ihn einreicht. Eine separate Bewertungsinstanz identifiziert Schwächen und triggert Korrekturen.
def self_critique(agent, output, task):
"""Agent bewertet eigenen Output und korrigiert bei Bedarf."""
critique_prompt = f"""
Aufgabe: {task}
Generierter Output: {output}
Bewerte den Output kritisch:
1. Erfüllt er die Anforderungen vollständig?
2. Welche Schwachstellen oder Fehler gibt es?
3. Wie kann der Output verbessert werden?
"""
critique = agent.generate(critique_prompt)
if critique.has_issues:
improved = agent.generate(
task,
previous_output=output,
critique=critique
)
return improved
return output
Dieses Pattern ist inspiriert von DeepSeek GRM (Generative Reward Model) – einem System, bei dem das Modell lernt, seine eigenen Ausgaben zu bewerten und on-the-fly zu verbessern. In der LLM-Agenten-Welt wird daraus ein zweistufiger Prozess:
- Generierung: Agent erzeugt Output
- Kritik: Separater Prompt bewertet den Output
- Korrektur: Agent verbessert basierend auf der Kritik
4. Aktuelle Forschung: Drei Ansätze
Die akademische Forschung liefert drei relevante Konzepte, die das Verständnis von „selbstlernend" für LLM-Agenten schärfen:
Sakana AI: Transformer Quadratmodell
Sakana AI demonstriert ein System, das seine Gewichte zur Laufzeit dynamisch anpasst – ohne erneutes Training. Die Übersetzung auf LLM-Agenten: dynamische Prompt-Selektion. Statt einen festen System-Prompt zu verwenden, wählt der Agent kontextabhängig aus einem Pool von Strategien:
STRATEGIES = {
"conservative": "Generiere minimalen, sicheren Code. Vermeide Komplexität.",
"exploratory": "Probiere neue Ansätze. Nutze moderne Libraries.",
"defensive": "Fokus auf Error-Handling und Edge-Cases.",
}
def select_strategy(task, history):
"""Wählt Strategie basierend auf Aufgabentyp und bisherigem Erfolg."""
if history.recent_failures > 2:
return STRATEGIES["conservative"]
if task.complexity == "low":
return STRATEGIES["exploratory"]
return STRATEGIES["defensive"]
SVFT: Singular Value Fine Tuning
SVFT zerlegt Gewichtsmatrizen via SVD (Singular Value Decomposition) in Komponenten, die einzeln hoch- oder heruntergeregelt werden – Skill-Regler für spezifische Fähigkeiten. Für LLM-Agenten inspiriert das einen Skill-Modulations-Ansatz:
SKILL_WEIGHTS = {
"code_generation": 0.8,
"debugging": 0.6,
"testing": 0.7,
"architecture": 0.5,
}
def modulate_skills(skill_weights, feedback):
"""Passt Skill-Gewichtung basierend auf Feedback an."""
updated = dict(skill_weights)
for skill, score in feedback.skill_scores.items():
if skill in updated:
# Exponentiell gleitender Durchschnitt
updated[skill] = 0.7 * updated[skill] + 0.3 * score
return updated
DeepSeek GRM: Generative Reward Model
DeepSeek GRM kombiniert Generierung und Bewertung in einem Modell. Es lernt aus Fehlern, kritisiert sich selbst und verbessert die Leistung on-the-fly. Das Konzept ist direkt anwendbar auf LLM-Agenten (siehe Säule 3: Selbstkritik).
5. Was „selbstlernend" nicht bedeutet
Eine klare Abgrenzung verhindert Missverständnisse:
| ❌ Nicht selbstlernend | ✅ Selbstlernend |
|---|---|
| LLM beantwortet Fragen (statische Inferenz) | Agent speichert Ergebnisse und nutzt sie für zukünftige Aufgaben |
| Chat mit Konversationshistorie (flüchtiges Gedächtnis) | Persistentes Gedächtnis über Sessions hinweg |
| Fine-Tuning eines Modells (offline, manuell) | Echtzeit-Anpassung der Strategie basierend auf Feedback |
| Einmaliges Prompt-Engineering | Dynamische Prompt-Selektion aus einem Pool erprobter Strategien |
| RAG ohne Feedback | RAG mit Feedback-Loop: erfolgreiche Ergebnisse fließen zurück |
6. Die Architektur: Vom LLM zum lernenden System
Die drei Säulen ergeben zusammen eine Architektur, die über die reine Inferenz eines LLMs hinausgeht:
┌─────────────┐
│ Aufgabe │
└──────┬──────┘
▼
┌────────────────────────┐
│ Langzeitgedächtnis │──── Ähnliche Erfahrungen abrufen
└────────────┬───────────┘
▼
┌────────────────────────┐
│ LLM-Agent │──── Strategie-Selektion
│ (Generierung) │
└────────────┬───────────┘
▼
┌────────────────────────┐
│ Selbstkritik │──── Output bewerten
└────────────┬───────────┘
▼
┌────────────────────────┐
│ Umgebung │──── Tests, Metriken, Reviewer
│ (Feedback) │
└────────────┬───────────┘
▼
┌────────────────────────┐
│ Gedächtnis-Update │──── Episode speichern
└────────────┬───────────┘
▼
┌─────────────┐
│ Ergebnis │
└─────────────┘
Jede Komponente ist austauschbar. Das LLM kann GPT-4, Claude oder ein Open-Source-Modell sein. Das Gedächtnis kann FAISS, ChromaDB oder eine einfache JSON-Datei nutzen. Die Umgebung kann aus automatisierten Tests, menschlichem Feedback oder einer Kombination bestehen.
7. Fazit
„Selbstlernend" bedeutet bei LLM-Agenten nicht dasselbe wie in klassischem ML. Es gibt keine Gradient-Updates, kein Backpropagation zur Laufzeit. Stattdessen entsteht Lernen durch eine Feedback-Architektur aus drei Säulen:
- Feedback-Loops schließen den Kreis zwischen Aktion und Bewertung
- Persistentes Gedächtnis macht Erfahrungen über Sessions hinweg verfügbar
- Selbstkritik erhöht die Qualität vor der Einreichung
Die aktuelle Forschung (Sakana AI, SVFT, DeepSeek GRM) liefert Konzepte, die – übersetzt auf LLM-Agenten – zu dynamischer Strategie-Selektion, Skill-Modulation und integrierter Selbstbewertung führen.
Der nächste Artikel der Serie behandelt Reinforcement Learning für Code-Agenten – das formale Framework, das diese Feedback-Architektur in eine mathematisch fundierte Struktur bringt.
Quellen & Ressourcen
- Mnih, V. et al. (2015): Human-level control through deep reinforcement learning. Nature 518, 529–533. – Experience Replay als Kern-Technik für Deep RL.
- Sakana AI (2024): Transformer²: Self-adaptive LLMs. – Dynamische Gewichtsanpassung zur Laufzeit.
- SVFT (2024): Singular Value Fine-Tuning: Few-shot Adaptation of LLMs. – SVD-basierte Skill-Modulation.
- DeepSeek (2025): DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. – Selbstverbesserung durch generatives Reward-Modell.
- Russell, S. & Norvig, P. (2020): Artificial Intelligence: A Modern Approach. 4th Edition. – Standardwerk für RL-Grundlagen und Agenten-Architektur.
→ Vollständiger Code: src/