> *"Ohne die Abstraktionsebene von Kopadze versuchen Entwickler oft, komplexe Systeme in LangGraph zu bauen, indem sie entweder einen riesigen, instabilen Single-Agent-Loop nutzen oder einen starren Pipeline-Graph verdrahten."*
> — Rüdiger, OME Topic 13, 2026-07-26
## Überblick
Die Architecture Triade beschreibt die drei notwendigen Säulen der Agenten-Architektur, die zusammenwirken müssen, um robuste, skalierbare Agenten-Systeme zu bauen. Jede Säule adressiert eine andere Frage:
**Perspektive:** Steinberger adressiert die Dynamik und Metrik des Agentenverhaltens.
**Kernfragen:**
- Wann bricht ein Loop ab?
- Wie verhindern wir Halluzinationen in der Feedback-Schleife?
- Welcher Threshold entscheidet über "gut genug"?
- Wie bleibt ein Verifier-Loop mathematisch und logisch stabil?
**Rolle:** Liefert die wissenschaftliche/konzeptionelle Grundlagenarbeit für die Selbstkorrektur von LLMs (Self-Correction, Reflection, Grounding).
**Lücke ohne die anderen:** Reines Loop-Engineering erklärt, wie ein Verifier-Loop stabil bleibt, aber nicht, wie man 5 verschiedene Spezialagenten miteinander arrangiert. Es fehlt die Topologie.
**Rolle:** Stellt sicher, dass der Zustand deterministisch durch gerichtete Graphen fließt — mit Built-in Persistenz, Tracing, HITL und Parallelität.
**Gefahr ohne Patterns:** LangGraph ist eine mächtige "Turing-vollständige" Infrastruktur — und genau das ist die Falle. Da man mit Nodes und Edges alles bauen kann, entstehen in der Praxis unlesbare, zusammengeschusterte "Spaghetti-Graphen", weil Entwickler ohne ein klares Pattern einfach Nodes aneinanderreihen.
**Perspektive:** Die fehlende Semantik zwischen Loop-Engineering und Framework.
**Rolle:** Kopadze liefert die Architektur-Muster (Shapes), die beschreiben, wie Information durch den Graph strömen soll — ähnlich wie die **Gang of Four (GoF)** in der OOP Design Patterns (Singleton, Factory, Strategy) lieferte.
**Kopadze-Shapes:**
| Shape | Beschreibung | Anwendungsfall |
|-------|-------------|----------------|
| **Parallel Fan-Out** | Verteilung einer Aufgabe auf mehrere Sub-Agenten | Unabhängige Teilaufgaben |
**Warum Kopadze die Lücke füllt:** Er übersetzt das abstrakte Loop-Engineering von Steinberger in konkrete Topologien, die sich direkt in LangGraph-Graphen gießen lassen.
## Das Diamond Pattern — Das mächtigste Workhorse
Das Diamond-Pattern (Fan-Out + Verifier / Join) löst das fundamentale Dilemma monolithischer LLM-Prompts: Ein einzelner Prompt verliert an Fokus und Qualität, je mehr Aufgaben er gleichzeitig lösen soll.
1.**Parallel Fan-Out (Verteilung & Spezialisierung):** Statt ein einziges Modell mit einer riesigen Aufgabe zu überfordern (wo der Kontext verwaschen wird), bricht der Start-Node das Problem in synchrone/asynchrone Teilaufgaben auf. Jeder Zweig hat einen spezialisierten Prompt, ggf. eigene Tools oder sogar schlankere/günstigere Modelle (z. B. Haiku/Mini für Sub-Tasks) — eine direkte Verbindung zum [[../../architecture/model-routing.md|Model Routing]]-Pattern.
2.**Der Evaluator / Verifier (Der Steinberger-Join):** Am Ende des Fan-Out läuft die Information nicht einfach ungeprüft zusammen (Merge), sondern trifft auf ein Verifier-Node. Dieser Prüfknoten agiert als Qualitätstor: Er prüft Konsistenz, halluzinierte Daten oder fehlende Teile. Der entscheidende Clou: Scheitert der Verifier, geht es nicht zurück an den Start, sondern gezielt in eine Kopadze-Loop an den betreffenden Sub-Knoten zurück.
### Verbindung zur Triade
Das Diamond Pattern ist die praktische Synthese aller drei Säulen:
- **Kopadze** liefert die Shape (Diamond-Topologie)
- **Steinberger** liefert den Verifier-Mechanismus (Abbruchkriterien, Thresholds, Loop-Control)
Ohne die Abstraktionsebene von Kopadze versuchen Entwickler oft, komplexe Systeme in LangGraph zu bauen, indem sie entweder einen riesigen, instabilen Single-Agent-Loop nutzen oder einen starren Pipeline-Graph verdrahten. Erst das Verständnis von Kopadzes Shape-Vokabular erlaubt es:
1. Den Problemraum in erprobte Topologien (wie das Diamond-Pattern) zu zerlegen.
2. Das Loop-Engineering nach Steinberger punktuell an den Verifier-Nodes anzudocken.
3. Das Ganze in LangGraph sauber, wartbar und skalierbar zu implementieren.
*Hinzugefügt 2026-07-26 — basierend auf @steipete's Post "am I a graph engineer now".*
**Perspektive:** Codex als Übersetzer von visuellen Graphen in ausführbaren Code. Die fehlende Automatisierungsebene, die die Triade vervollständigt.
### Die Entdeckung
Am 24.07.2026 postete **Alex Kotliarskyi (@alexk, OpenAI Engineering Lead)** einen Workflow, der sofort von Peter Steinberger (@steipete) aufgegriffen wurde:
> "How to graph-max with Codex and 5.6 Sol:
> 1. Draw a graph (literally in any tool, even on paper)
> 2. Send it to Codex and say 'write a code mode script that implements this workflow, run it with <your inputs>'
> 3. There's no step 3, it just works."
Steinberger antwortete mit: "am I a graph engineer now" — eine selbstironische Bestätigung, dass sein Loop-Engineering jetzt durch Codex in Graph-Code übersetzt wird.
1.**Kopadze** definiert das Shape (z.B. Diamond-Pattern)
2.**Steinberger** definiert die Loop-Bedingungen (Wann evaluieren? Welcher Threshold?)
3.**Codex** übersetzt die Shapes + Parameter in ausführbaren LangGraph-Code
4.**LangGraph** führt den generierten Code als Runtime aus
### Was ist hier wirklich neu?
Bisher wurde das Shape-Wissen (Kopadze) manuell in LangGraph gegossen: Ein Entwickler sieht das Diamond-Pattern und übersetzt es per Hand in Nodes und Edges. Der Graph Compiler automatisiert diesen Schritt:
- **Shape → Code:** Das Diamond-Pattern wird nicht mehr von Hand implementiert, sondern von Codex aus dem Diagramm generiert
- **Visuelle Programmierung:** Die Graph-Struktur wird zum Source Code — analog zu UML → Code-Generierung in klassischer Softwareentwicklung
- **Demokratisierung:** Auch Nicht-Entwickler können Agent-Workflows entwerfen (zeichnen) und ausführen lassen
### Einordnung in die Triade-Entwicklung
Die Drei-Säulen-Triade beschrieb, *wie* man Agenten-Architektur denken und bauen sollte. Der Graph Compiler automatisiert diesen Prozess:
- **Früher:** Stunde → Shape denken → in Code gießen
Die Automatisierungsebene macht die Triade erst vollständig: Sie schließt den Kreis von der Idee über das Design zur Implementation — und zurück zur Idee (iterative Verfeinerung durch erneutes Zeichnen).
### Rezeption und Community
- Steinbergers Post erreichte ~730K Views, 4.7K Likes, 333 Reposts und 5.5K Bookmarks — ein starkes Signal, dass der Graph Compiler-Ansatz auf breites Interesse stößt
