- Die meisten Teams, die LLM-basierte Systeme entwickeln, versuchen zuerst Agenten zu bauen, scheitern aber oft schnell an Komplexität, mangelnder Steuerbarkeit und schwieriger Fehlersuche
- Echte Agentenmuster, die Memory, RAG, Tool-Nutzung und Workflow-Steuerung zugleich benötigen, sind in der Praxis selten; die meisten Probleme lassen sich mit einfachen Workflows (Chaining, Parallelisierung, Routing usw.) effektiver lösen
- Es wird empfohlen, zuerst fünf in der Praxis nützliche LLM-Workflow-Muster anzuwenden und Agenten nur dann vorsichtig einzusetzen, wenn sie wirklich nötig sind
- Prompt Chaining, Parallelisierung, Routing, Orchestrator-Worker, Evaluator-Optimizer
- Selbst wenn Agenten nötig sind, bleiben menschliche Mitwirkung, klare Kontrolle und Observability der Schlüssel
Sind AI-Agenten wirklich nötig?
- Einblicke von Hugo Bowne-Anderson, der verschiedenen Engineers und Teams wie Netflix, Meta und der US Air Force Beratung und Schulungen zum Aufbau von LLM-Systemen bietet
Der falsche Start: Warum alle von Agenten besessen sind
- Viele Teams führen zu Beginn von LLM-Projekten zuerst komplexe Strukturen wie Agenten, Memory, Routing, Tool-Nutzung und Persönlichkeitsdesign ein
- In der Praxis treten jedoch in vielen Bereichen wie Zusammenarbeit zwischen Agenten, Tool-Auswahl und Langzeitgedächtnis fortlaufend Fehlverhalten und Ausfälle auf
- Als Beispiel wird ein auf CrewAI basiertes Forschungsagenten-Projekt genannt, in dem die einzelnen Rollen (Researcher, Zusammenfasser, Koordinator) nicht wie erwartet zusammenarbeiteten und das System hilflos zusammenbrach
Was ist ein Agent?
- Vier Eigenschaften von LLM-Systemen: Memory, Information Retrieval (RAG), Tool-Nutzung und Workflow-Steuerung
- Die letzte Eigenschaft, die Workflow-Steuerung (wenn das LLM selbst den nächsten Schritt oder den Einsatz von Tools entscheidet), wird als agentische Eigenschaft bezeichnet
- Für die meisten realen Aufgaben zeigen einfache Workflows (Chaining, Routing usw.) tatsächlich eine höhere Stabilität
Welche in der Praxis nützlichen LLM-Workflow-Muster man statt Agenten verwenden sollte
1. Prompt Chaining
- Beschreibung: Mehrere Aufgaben werden in eine Reihe von Schritten (eine Kette) aufgeteilt, sodass das LLM jeden Schritt nacheinander verarbeitet
- Beispiel: Aus einem LinkedIn-Profil Name, Titel und Firmeninformationen extrahieren → zusätzliche Informationen über die Firma ergänzen (Mission, Hiring usw.) → auf Basis von Profil- und Firmeninformationen eine personalisierte E-Mail schreiben
- Vorteile: Jeder Schritt ist klar getrennt, wodurch sich Ursachen bei Bugs leicht nachverfolgen und beheben lassen; das erleichtert Debugging und Wartung
- Leitlinien:
- Geeignet für sequenziell verbundene Tasks
- Fällt auch nur ein Schritt aus, kann die gesamte Kette scheitern
- Die Aufteilung in kleine Arbeitseinheiten ermöglicht vorhersehbare Ergebnisse und einfaches Debugging
2. Parallelisierung
- Beschreibung: Mehrere unabhängige Aufgaben werden gleichzeitig ausgeführt, um den gesamten Prozess zu beschleunigen
- Beispiel: Aus den Profilen mehrerer Personen parallel verschiedene Merkmale wie Ausbildung, Berufserfahrung und Skills extrahieren, um die gesamte Verarbeitungszeit zu verkürzen
- Vorteile: Effizient auch bei großen Datenmengen, etwa bei unabhängiger Datenextraktion oder -verarbeitung; passt gut zu verteilten Umgebungen
- Leitlinien:
- Geeignet, wenn die einzelnen Tasks voneinander unabhängig sind und parallele Ausführung die Gesamtgeschwindigkeit deutlich erhöht
- Auf Ausnahmefälle wie Race Conditions und Timeouts bei paralleler Ausführung achten
- Passend für die Verarbeitung großer Datenmengen und die gleichzeitige Analyse mehrerer Quellen
3. Routing
- Beschreibung: Das LLM klassifiziert Eingabedaten und verzweigt sie automatisch in den jeweils passenden Workflow
- Beispiel: In einem Kundensupport-Tool wird klassifiziert, ob es sich um eine Produktanfrage, ein Zahlungsproblem oder eine Rückerstattungsanfrage handelt; danach erfolgt die automatische Weiterleitung in den passenden Workflow, bei unklaren Typen an einen Standard-Handler
- Vorteile: Saubere Trennung verschiedener Fälle durch spezialisierte Verarbeitungslogik je Eingabetyp
- Leitlinien:
- Sinnvoll, wenn unterschiedliche Eingabetypen oder Situationen getrennt behandelt werden müssen
- Bei Grenzfällen oder Ausnahmen kann das Routing scheitern oder Fälle übersehen
- Ein Catch-all-Handler für nicht klassifizierte oder Ausnahmefälle muss unbedingt vorgesehen werden
4. Orchestrator-Worker
- Beschreibung: Ein LLM in der Rolle des Orchestrators zerlegt Aufgaben und trifft Entscheidungen, delegiert Teilaufgaben an Worker (ausführende LLMs) und steuert Ablauf und Reihenfolge direkt
- Beispiel: Ein Zielprofil wird in Tech oder Non-Tech klassifiziert → bei Tech wird die Erstellung der E-Mail an einen spezialisierten Worker delegiert, bei Non-Tech an einen anderen Worker
- Vorteile: Trennung von Entscheidungsfindung (Klassifikation/Bewertung) und Ausführung (Einzelverarbeitung); vorteilhaft für dynamische Flow-Kontrolle und Skalierung
- Leitlinien:
- Geeignet, wenn Tasks jeweils spezialisierte Behandlung benötigen und komplexe Verzweigungen oder stufenweise Koordination erforderlich sind
- Wenn der Orchestrator Tasks falsch zerlegt oder falsch delegiert, entstehen Fehler im gesamten Flow
- Die Logik sollte explizit und einfach bleiben; Delegation, Reihenfolge und Abbruchbedingungen müssen klar entworfen werden
5. Evaluator-Optimizer
- Beschreibung: Das LLM bewertet ein Ergebnis (Score/Feedback) und überarbeitet bzw. verbessert es wiederholt, wenn es den Kriterien nicht genügt
- Beispiel: E-Mail-Entwurf erstellen → Evaluator vergibt Qualitätsbewertung/Feedback → wenn ein definierter Schwellenwert erreicht ist oder die maximale Zahl an Iterationen überschritten wurde, endet der Prozess; andernfalls wird erneut überarbeitet
- Vorteile: Die Qualität des finalen Outputs kann iterativ bis zu einem Zielniveau verbessert werden; gut geeignet für den Einsatz quantitativer Kriterien
- Leitlinien:
- Geeignet für Situationen, in denen Qualität wichtiger ist als Geschwindigkeit und iterative Optimierung nötig ist
- Ohne Abbruchbedingung kann das System in eine Endlosschleife geraten
- Klare Qualitätskriterien und Iterationslimits sind zwingend erforderlich
Wann Agenten wirklich nötig sind
- Agenten entfalten ihren Wert besonders in Umgebungen, in denen Human-in-the-loop in Echtzeit garantiert ist
- Beispiel 1: Unterstützung in Data Science – bei SQL-Queries, Visualisierung und Empfehlungen zur Datenanalyse probiert das LLM kreativ Dinge aus, während Menschen die Ergebnisse beurteilen und korrigieren
- Beispiel 2: Kreativer Partner – bei Ideen für Werbetexte, Headline-Vorschlägen oder Empfehlungen zur Textstruktur sind menschliche Richtungsanpassung und Qualitätsprüfung zentral
- Beispiel 3: Helfer beim Code-Refactoring – bei Vorschlägen zu Design Patterns, Erkennung von Edge Cases oder Code-Optimierung geben Entwickler ihre Freigabe oder ergänzen nach
- Merkmal: Agenten funktionieren am besten nicht dann, wenn sie „alles selbst“ erledigen, sondern in Umgebungen, in denen Menschen Fehler und Richtung in Echtzeit steuern
Wann Agenten nicht geeignet sind
- Enterprise- und mission-critical Systeme (Finanzen, Medizin, Recht usw.):
- Weil Zuverlässigkeit der Automatisierung und deterministisches Verhalten wichtig sind, ist eine Struktur riskant, in der LLM-Agenten Entscheidungen treffen
- Stattdessen sollten klare Kontrollmuster wie Orchestrator und Routing eingesetzt werden
- Alle Situationen, in denen Stabilität und Vorhersehbarkeit wichtig sind
- Typische Fehlfälle: Agenten wählen ohne Kontext oder Memory wiederholt die falschen Tools oder die Arbeitsteilung/Koordination scheitert, sodass der gesamte Flow zusammenbricht
- Häufige Ursachen für das Scheitern von Agentensystemen in der Praxis
- Kein explizites Memory-System entworfen, wodurch Kontext verloren geht
- Zu wenige Beschränkungen bei der Tool-Auswahl (unnötige/falsche Tool-Nutzung)
- Verlass auf freie Delegationsstrukturen, was zur gescheiterten Koordination der Zusammenarbeit führt
Lehren für das Design in der Praxis
- Selbst bei der Einführung von Agenten sind Design, Observability und Kontrollmechanismen auf dem Niveau eines hochwertigen Softwaresystems zwingend erforderlich
- Statt komplexer Agenten-Frameworks ist ein Design mit Observability, klaren Evaluationsschleifen und direkt kontrollierbarer Struktur schneller und sicherer
Fazit (TL;DR)
- Agenten werden oft überschätzt und übermäßig eingesetzt
- Für die meisten realen Aufgaben sind einfache Workflow-Muster besser geeignet
- Agenten entfalten ihren Wert in Umgebungen, in denen Menschen direkt eingreifen
- In stabilen Systemen sind sie eher ein Risikofaktor
- Systeme sollten mit Observability, expliziter Kontrolle und iterativen Evaluationsstrukturen entworfen werden
- Statt komplexer Agenten-Frameworks ist ein Design mit Observability, klaren Evaluationsschleifen und direkt kontrollierbarer Struktur in der Praxis der Schlüssel zu einer schnelleren und sichereren Entwicklung LLM-basierter Services
6 Kommentare
Vor einem Monat habe ich mit CURSOR begonnen, um zu lernen, was AI Coding ist, und habe mich an die Entwicklung eines Entwicklungs-Frameworks gemacht.
Etwa drei Wochen lang wiederholte sich, dass Quellcode, der erfolgreich war und von einem AI Agent validiert worden war, wieder kaputtging. Ich versuchte mit allen möglichen Methoden, den AI Agent zu kontrollieren, aber ich scheiterte.
Dann wurde mir klar, dass es Vorrang hat, vor der Entwicklung des Entwicklungs-Frameworks zunächst den Quellcode zu entwickeln, der den AI Agent kontrolliert.
Schließlich habe ich genau einen Monat nach dem Start, bei dem ich zunächst verstehen wollte, was AI überhaupt ist, das Ergebnis erreicht, Software fertigzustellen, die zu 100 % durch AI implementiert und zu 100 % betrieben werden kann, wobei ich den AI Agent vollständig kontrolliere (genauer gesagt: ohne dass externe LLMs oder AI Agents nötig sind).
Derzeit bin ich am 14. Tag dabei, diese META AI für zusätzliche Weiterentwicklung weiter zu trainieren und dabei Betriebsregeln zu erstellen und durchsetzen zu lassen. Gleichzeitig migriere, verbessere und standardisiere ich drei MES-Systeme, die zuvor von Menschen unvollständig erstellt worden waren, und befinde mich dabei in der Abschlussphase.
Und jetzt bereite ich bereits die nächste Evolution vor.
Ist es bei Prompt Chaining dann aber nicht auch vertretbar, die LLM, die einzelne Prompts ausführt, den Ausführungs-Worker, den Orchestrator-Worker, die Evaluator-LLM usw. jeweils als Agenten zu bezeichnen?
Ah, es gibt also die Aussage: „Die letzte Workflow-Steuerung (dass das LLM selbst entscheidet, ob der nächste Schritt erfolgt oder ein Tool verwendet wird) wird als agentische Eigenschaft bezeichnet.“ Verstanden. Dann ist das also ein Text, der auf autonome Agenten abzielt. Ich kenne mich mit Agenten noch nicht so gut aus, deshalb ...
Hacker-News-Kommentare
https://github.com/astronomer/airflow-ai-sdk
Ich arbeite derzeit ebenfalls an einem Computer-Use-Agenten namens UseDesktop
https://youtu.be/aBkbsvMxP_A?si=uaugxKQEu4ZEz7jq
usedesktop.com
und stimme dem größtenteils zu.
Der Beitrag behandelt eher nur einen groben Überblick als wirklich praktische Tipps. Wenn ich noch ein paar Hinweise zur Entwicklung von LLM-basierten agentischen Systemen bzw. Agenten ergänzen darf: LLMs basieren letztlich auf Transformern (d. h. probabilistischem Schlussfolgern; sie verstehen auf Basis des aktuellen Tokens/States den nächsten Token nicht wirklich kontextuell/semantisch und geben das nächste Wort nicht „bewusst“ aus, sondern erzeugen Outputs probabilistisch). Deshalb liefern sie selbst mit gutem System-Prompt oft nicht die gewünschte Antwort (z. B. wenn man eine Antwort im JSON-Format verlangt und gelegentlich eine
}fehlt). Daher ist es Pflicht, immer mehrere regex-basierte Fallback-Funktionen hinzuzufügen.Und wenn man einen System-Prompt für strukturierte Outputs schreibt, verwendet man in der Regel eher ein Non-Reasoning-Modell. Je länger der Kontext wird, desto häufiger treten Halluzinationen auf, daher ist es oft besser, mehrere System-Prompts zu erstellen und zu chainen.
Wenn man einen Service entwickelt, können verschiedene Fehler auftreten, deshalb ist es entscheidend, die Service-Architektur modular und fault-tolerant zu entwerfen (z. B. den Supervisor-Agenten asynchron und die übrigen Agenten synchron), besonders bei agentischen Systemen bzw. Agenten, bei denen häufig unerwartete Outputs auftreten.
Deshalb sollte man von Anfang an beim Schreiben des Codes möglichst das SRP einhalten und deklarativ arbeiten; ich würde sagen, dass ein funktionaler Ansatz sinnvoll ist (= keine Side Effects und ein intuitiver Flow).
Je nachdem, ob man LLMs über eine API nutzt oder die Modelle selbst serven will, sieht es etwas anders aus. Falls man jedoch ein SLM oder LLM selbst serven möchte, sollte man das Model Serving nicht auf demselben Server betreiben, auf dem auch das Backend gehostet wird. Es ist fault-toleranter und besser, IO-bound Tasks und CPU-bound Tasks (d. h. Tasks, die eine GPU benötigen, Matrixmultiplikationen usw.) auf getrennten Servern zu platzieren (z. B. CPU-bound Tasks auf Runpod hosten).
Es gibt noch viele weitere Entwicklungstipps, aber ich höre hier auf, bevor es zu lang wird.
Ich hoffe, das hilft jemandem.
Vielen Dank, dass Sie Ihre wertvollen Erfahrungen und Meinungen geteilt haben. Die Meinung von jemandem, der direkt vor Ort arbeitet, ist wirklich eine große Hilfe.