Graph Engineering erklärt: Knoten, Kanten und LangGraph in der Praxis

Alle paar Monate bekommt die KI-Entwicklung ein neues "-Engineering"-Etikett, und das jüngste heißt Graph Engineering. Der Begriff verbreitete sich nach einem Beitrag von Peter Steinberger, der den Open-Source-Agenten OpenClaw entwickelt hat und heute bei OpenAI arbeitet, und landete deshalb in sehr vielen Timelines. Die vernünftige Reaktion ist die Frage, ob er etwas Neues bezeichnet oder einfach ein weiteres Buzzword ist.

Die kurze Antwort: Größtenteils ist es ein neuer Name für etwas, das Entwickler von Agenten ohnehin schon tun. Hier die längere Fassung.

Eine kurze Geschichte der Etiketten

Das Feld hat schon mehrere Namenswellen hinter sich.

Zuerst kam Prompt Engineering. Damit ist gemeint, Prompts so präzise und klar zu formulieren, dass das Modell versteht, was man braucht.

Dann folgte Context Engineering, als ein Prompt allein nicht mehr alles transportieren konnte, was der Agent vor dem Start einer Aufgabe braucht. Man hängt weiteres Material an, etwa Screenshots, Markdown-Dateien und Code, damit der Agent sowohl die Absicht als auch die Umgebung erfasst.

Harness Engineering war wohl der größte Schritt. Statt dem Agenten nur Informationen zu geben, baut man eine Umgebung um ihn herum: Projektdetails, die Tools, die er nutzen darf, ein Gedächtnis früherer Arbeit sowie Richtlinien und Leitplanken, die ihn in der Spur halten.

Als Nächstes kommt Loop Engineering. Man weist den Agenten an, so lange an einem Problem zu iterieren, bis er ein Erfolgskriterium erfüllt. Ein typischer Fall ist ein Zusammenfassungs-Agent, der einen Bericht zu einem Thema schreiben und seinen eigenen Entwurf dann immer weiter verbessern soll, bis eine Qualitätsschwelle erreicht ist, die er selbst prüft, statt ihn an einen separaten Review-Schritt zu geben.

Es geht darum, die eigene Beteiligung zu verringern, indem man das Testen an den Agenten delegiert. Man prüft nicht mehr jede Iteration und gibt Feedback. Der Agent bewertet das aktuelle Ergebnis anhand der Kriterien und korrigiert seinen Ansatz selbst. Das hat eine Kehrseite, denn ein sich selbst überlassener Agent kann auch aus dem Ruder laufen und die eigenen Tokens verbrennen. Wenn das Ideal aber ein System ohne Menschen in der Schleife ist, geht das in diese Richtung.

Die meisten, die Agenten bauen, haben das schon lange vor dem Etikett so gemacht. Neu ist das Vokabular, nicht das Prinzip. Graph Engineering folgt demselben Muster.

Was einen Graphen ausmacht

Drei Zutaten definieren einen Graphen.

1. Knoten. Ein Knoten ist eine abgegrenzte Recheneinheit mit einer klar erkennbaren Aufgabe: eine Funktion, die den aktuellen Zustand entgegennimmt und eine Aktualisierung zurückgibt. In LangGraph registriert man ihn mit graph.add_node(name, fn).
2. Kanten. Eine Kante gibt die Kontrolle von einem Knoten an den nächsten weiter. In LangGraph bedeutet graph.add_edge(a, b), dass Knoten b an die Reihe kommen kann, sobald Knoten a fertig ist. Die Richtung zählt: a führt zu b und nicht umgekehrt. Es gibt auch bedingte Kanten. Mit graph.add_conditional_edge(a, func) läuft die Funktion nach Knoten a und wählt den Knoten, der als Nächstes kommt.
3. Die Form. Knoten und Kanten bilden zusammen ein Muster, und diese Struktur zeigt sich erst, wenn man das verbundene Ganze betrachtet.

Graph Engineering in der Praxis

Um ein Gefühl dafür zu bekommen, nehmen wir einen mit LangGraph gebauten Agenten, der einen Treffpunkt für eine Gruppe von zwei bis fünf Personen auswählt, die weit auseinander wohnen und darüber streiten, welches Viertel sinnvoll ist. Er berücksichtigt echte Faktoren wie die Fahrzeit und die Zahl der Busumstiege für jede Person, statt einfach die Mitte der Karte zu nehmen.

Elf Knoten bilden den Graphen, und jeder erledigt genau eine Sache. Sie grenzen das Suchgebiet ein, prüfen die Erreichbarkeit für jede Person, erstellen eine Auswahl an Vierteln, suchen Lokale, bewerten sie und prüfen am Ende das Ergebnis. Bedingte Kanten gibt es nicht, also ist die Struktur auf dem Papier linear: Jeder Schritt führt zum nächsten, ohne Verzweigung.

Der LangGraph-Code, der sie definiert, ist unkompliziert:

# Initialize the graph with our shared state schema.
graph = StateGraph(MeetingState)
graph.add_node(”node0_search_area”, search_area_node)

# list the nodes
# register one reachability node per possible party member
for index, node in enumerate(REACHABILITY_NODES):
graph.add_node(f”reach_person{index + 1}”, node)
graph.add_node(”nodeC_shortlist”, shortlist_node)
graph.add_node(”nodeD_spots”, spot_finder_node)
graph.add_node(”nodeE_score”, scorer_node)
graph.add_node(”nodeF_review”, reviewer_node)

# list the edges
graph.add_edge(START, “node0_search_area”)
for index in range(len(REACHABILITY_NODES)):
graph.add_edge(”node0_search_area”, f”reach_person{index + 1}”)
graph.add_edge(f”reach_person{index + 1}”, “nodeC_shortlist”)
graph.add_edge(”nodeC_shortlist”, “nodeD_spots”)
graph.add_edge(”nodeD_spots”, “nodeE_score”)
graph.add_edge(”nodeE_score”, “nodeF_review”)
graph.add_edge(”nodeF_review”, END)

# Compile into a runnable graph.
compiled = graph.compile() Engineering w/ a Project

Das ist der ganze Graph, und er liest sich wie eine schlichte Pipeline.

Was die Struktur einbringt

Selbst ein linearer Graph hat praktischen Nutzen. Jeder Knoten liest aus einem gemeinsamen Zustandsobjekt und schreibt hinein, sodass man genau sieht, was jeder Schritt verändert hat. Ein fehlschlagender Schritt lässt sich leicht isolieren und neu ausführen, weil er eine kleine Funktion mit definierter Eingabe ist. Man kann einen Knoten austauschen oder verbessern, etwa die Bewertung der Lokale, ohne die anderen anzufassen. Und sobald eine Verzweigung oder eine Wiederholungsschleife nötig wird, ist eine bedingte Kante eine kleine Änderung und kein Neuschreiben.

Nichts davon ist exotisch. Es ist ganz normales Softwaredesign, angewendet auf Agenten-Workflows, und deshalb klingt das Etikett dramatischer als die Idee.

Was ist es also?

Graph Engineering ist kein neues Konzept. Es ist ein frischer Name für einen Ansatz, der üblich geworden ist, seit immer mehr Menschen Agenten bauen. Wer es noch nicht ausprobiert hat, sollte es mit LangGraph oder dem Framework versuchen, das er ohnehin mag. Das Etikett ist weniger wichtig als die Gewohnheit: die Arbeit in kleine Schritte mit jeweils einem Zweck zerlegen, die Verbindungen zwischen ihnen explizit machen und den gemeinsamen Zustand übersichtlich halten.