ingest(xpost): anatoli-kopadze graph engineering guide

2026-07-26 16:32:19 +02:00 · 2026-07-26 16:32:19 +02:00 · 89a6a64fe8
commit 89a6a64fe8
parent 7f029d2ae9
4 changed files with 234 additions and 1 deletions
--- a/raw/xpost/2026-07-25_anatoli-kopadze-graph-engineering-guide.md
+++ b/raw/xpost/2026-07-25_anatoli-kopadze-graph-engineering-guide.md
@ -0,0 +1,64 @@
+---
+type: xpost
+source_url: https://x.com/AnatoliKopadze/status/xxxxxxxx
+retrieved: 2026-07-26
+author: "@AnatoliKopadze"
+is_thread: true
+tags: [graph-engineering, ai-agents, agent-architecture, workflows, orchestration, graph-shapes, parallel-execution, verification-nodes]
+people: [anatoli-kopadze]
+---
+
+# Graph Engineering Guide for AI Agents
+
+**Author:** Anatoli Kopadze (@AnatoliKopadze)
+**Posted:** 2026-07-25
+**Source:** X-Thread (viral, full thread captured via OME-Community)
+
+## Summary
+
+Anatoli Kopadze hat einen viralen Thread über Graph Engineering für AI Agents veröffentlicht — die 4 fundamentalen Shapes (Chain, Diamond, Router, Cycle) plus einen Step-by-Step-Build-Guide.
+
+## Thread Content
+
+### Shape 0 – Basics
+
+Ein Graph ist ein visueller Plan für AI Workflows. Tasks = Nodes, Dependencies = Edges. Graph Engineering optimiert den Plan so, dass unabhängige Tasks parallel laufen statt sequentiell. Ersetzt alte lineare Loops.
+
+### Shape 1 – The Chain
+
+A → B → C. Nur wenn Tasks wirklich voneinander abhängen. Langsam, aber einfach.
+
+### Shape 2 – The Diamond (The Workhorse)
+
+Start → fan-out (parallel workers) → verifier/merge → output. Perfekt für Research, Market Scans, Code Reviews. Das ist das mächtigste Pattern für den Alltag.
+
+### Shape 3 – The Router
+
+Decision node evaluiert Ergebnis und routet zu passendem Pfad. Branching-Logik lebt in der Graph-Struktur, nicht im Model Guess.
+
+### Shape 4 – The Cycle
+
+Controlled Loop für Discovery-Work (Bug Sweeps, iterative Refinements). Braucht hard stop condition.
+
+### Step-by-Step: How to build a graph from scratch
+
+1. Define goal
+2. List every sub-task
+3. Draw dependencies
+4. Choose dominant shape (start with Diamond)
+5. Add Router/Cycle only where needed
+6. Add verification nodes
+7. Set limits (max parallel, max cycles, timeout)
+8. Test small
+9. Visualize and iterate
+10. Scale
+
+### Key Insight
+
+> "Most people use 10% of AI — type one prompt, close tab. The people using the other 90% aren't typing prompts at all. They're running agents in parallel, wired into graphs that check their own work."
+
+## Cross-References
+
+- Ergänzt die bestehende Graph-vs-Loop-Debatte ([[wiki/concepts/agents/graph-based-agents.md]] / [[wiki/concepts/agents/agent-loops.md]])
+- Konkretisiert das Shape-Vokabular, das bei LangGraph nur implizit existiert (Chain, Diamond, Router, Cycle)
+- Verwandt mit [[wiki/concepts/agents/graph-based-agents.md]] (Shape-Design als Vorstufe zur LangGraph-Implementation)
--- a/wiki/concepts/agents/graph-engineering.md
+++ b/wiki/concepts/agents/graph-engineering.md
@ -0,0 +1,155 @@
+---
+created: 2026-07-26
+updated: 2026-07-26
+sources:
+  - xpost/2026-07-25_anatoli-kopadze-graph-engineering-guide.md
+tags: [concept, agents, graph-engineering, workflows, orchestration, parallel-execution, verification, agent-architecture, shapes, chain, diamond, router, cycle]
+people: [anatoli-kopadze]
+---
+
+# Graph Engineering — Die 4 Fundamental Shapes für AI Agent Workflows
+
+> *"Most people use 10% of AI — type one prompt, close tab. The people using the other 90% aren't typing prompts at all. They're running agents in parallel, wired into graphs that check their own work."*
+> — Anatoli Kopadze (@AnatoliKopadze), Juli 2026
+
+## Definition
+
+**Graph Engineering** ist die Disziplin, AI-Workflows als gerichtete Graphen zu modellieren und zu optimieren. **Tasks** sind Nodes, **Dependencies** sind Edges. Das Ziel: unabhängige Tasks parallel laufen lassen statt sequentiell — und die klassische lineare Loop-Struktur durch einen optimierten, kontrollierten Plan ersetzen.
+
+Anders als [[graph-based-agents.md]] (das LangGraph als Implementierungsframework in den Mittelpunkt stellt), fokussiert Graph Engineering auf die **Shape-Klassifikation** — ein Vokabular von 4 fundamentalen Graph-Formen, die als Bausteine für jeden Agent-Workflow dienen.
+
+## Shape 0 – Basics: Graph als visueller Plan
+
+Jeder Graph besteht aus:
+- **Nodes (Tasks):** Was soll passieren? (z.B. `research`, `code`, `test`, `review`, `decide`)
+- **Edges (Dependencies):** Was muss vorher fertig sein?
+- **Parallelität:** Tasks ohne Abhängigkeiten können gleichzeitig laufen
+
+Der Shift von linearen Loops zu Graphen ist nicht nur technisch — es ist ein **Planungs-Paradigmenwechsel**: Statt "mach das immer wieder, bis es passt" → "zeichne den optimalen Pfad, dann führe ihn aus".
+
+## Shape 1 – The Chain (Sequentiell)
+
+```
+A → B → C
+```
+
+**Wann verwenden:** Nur wenn Tasks wirklich voneinander abhängen.
+**Vorteil:** Einfach, vorhersagbar, debug-bar.
+**Nachteil:** Langsam — nutzt keine Parallelität.
+
+> **Beispiel:** Datenbereinigung → Feature-Extraktion → Modell-Training. Jeder Schritt braucht den vorherigen.
+
+## Shape 2 – The Diamond (Der Arbeitgeber) ⬥
+
+```
+         ┌── Worker 1 ──┐
+Start ───┼── Worker 2 ──┼── Verifier/Merge ──→ Output
+         └── Worker N ──┘
+```
+
+**Wann verwenden:** Für die meisten Alltags-Workflows.
+**Was passiert:**
+1. **Start-Node:** Verteilt die Aufgabe
+2. **Fan-Out (Parallel Workers):** N unabhängige Agenten arbeiten parallel
+3. **Verifier/Merge-Node:** Sammelt Ergebnisse, prüft Qualität, konsolidiert
+4. **Output:** Fertiges Ergebnis
+
+**Anwendungen:**
+- **Research:** Mehrere Quellen parallel scannen → Synthese
+- **Market Scans:** Gleichzeitige Analyse verschiedener Segmente
+- **Code Reviews:** N Review-Agenten parallel → Merge der Findings
+
+> 💡 **Kopadzes Empfehlung:** Starte IMMER mit dem Diamond. Es ist das mächtigste Pattern für den Alltag.
+
+## Shape 3 – The Router (Entscheidungs-Verzweigung)
+
+```
+               ┌── Pfad A ──┐
+Decision Node ──┼── Pfad B ──┼──→ Output
+               └── Pfad C ──┘
+```
+
+**Wann verwenden:** Wenn das Ergebnis einer Task bestimmt, was als nächstes passiert.
+**Was passiert:**
+1. **Decision Node:** Ein Evaluations-Agent prüft das Ergebnis (z.B. "Ist der Code korrekt?")
+2. **Routing:** Basierend auf dem Ergebnis wird zu einem spezifischen Pfad geroutet
+3. **Ziel-Pfade:** Jeder Pfad hat seine eigene Logik
+
+**Kern-Insight:** Die Branching-Logik lebt in der **Graph-Struktur** (den Edges), nicht im **Model Guess** (dem Prompt). Das macht das Verhalten deterministischer, testbarer und sicherer.
+
+> **Beispiel:** Code-Generierung → Code-Review → [Bestanden? → Merge | Fehler gefunden? → Fix-Node | Sicherheitsproblem? → Escalation-Node]
+
+## Shape 4 – The Cycle (Kontrollierte Schleife)
+
+```
+                ┌─────────────────────────┐
+                │                         ▼
+Start ──→ Process ──→ Check Condition ──→ Stop (wenn erfüllt)
+                │
+                └── (weiter, wenn nicht erfüllt)
+```
+
+**Wann verwenden:** Für Discovery-Work und iterative Verfeinerung.
+**Wichtig:** Braucht eine **harte Stop-Bedingung** (max cycles, timeout, convergence threshold).
+
+**Anwendungen:**
+- **Bug Sweeps:** Wiederholte Tests, bis keine Fehler mehr gefunden werden
+- **Iterative Refinements:** Schrittweise Verbesserung eines Outputs
+- **Discovery Work:** Solange forschen, bis eine Schwelle erreicht ist
+
+> ⚠️ **Risiko:** Ohne harte Stop-Bedingung wird der Cycle zum Infinite Loop.
+
+## Step-by-Step: Graph from Scratch
+
+Kopadzes 10-Schritte-Plan für den Bau eines Agent-Graphen:
+
+1. **Define goal** — Was soll der Graph erreichen?
+2. **List every sub-task** — Alle Einzelschritte (egal ob parallel oder sequentiell)
+3. **Draw dependencies** — Welcher Schritt braucht welchen anderen?
+4. **Choose dominant shape** — Starte mit **Diamond** (Shape 2). Es passt für 80% der Fälle
+5. **Add Router/Cycle only where needed** — Füge Komplexität nur dort hinzu, wo der Diamond nicht reicht
+6. **Add verification nodes** — Jeder kritische Pfad braucht eine Qualitätskontrolle
+7. **Set limits** — Max parallel workers, max cycles, timeout, retry count
+8. **Test small** — Erst mit einem Mini-Datensatz, dann skalieren
+9. **Visualize and iterate** — Mach den Graphen sichtbar (Mermaid, LangGraph Studio), iteriere
+10. **Scale** — Erhöhe Parallelität, füge Quellen hinzu, deploye in Produktion
+
+## Vergleichstabelle: Shapes
+
+| Shape | Name | Parallelität | Komplexität | Anwendung | Stop-Bedingung |
+|-------|------|-------------|-------------|-----------|----------------|
+| 1 | Chain | ❌ Keine | Einfach | Strikt sequentielle Pipelines | Natürliches Ende |
+| 2 | Diamond | ✅ Hoch | Mittel | Research, Scans, Reviews | Merge/Verifier |
+| 3 | Router | ⚠️ Pro Pfad | Mittel | Entscheidungsbäume | Ziel-Pfad-Ende |
+| 4 | Cycle | ⚠️ Intern | Hoch | Discovery, Iteration | Hard Limit nötig |
+
+## Verhältnis zu Loops & LangGraph
+
+Kopadzes Graph Engineering ergänzt die bestehende [[graph-based-agents.md]]- und [[agent-loops.md]]-Debatte:
+
+- **Loops = konzeptionelle Grundlage** (ReAct-Pattern, Steinbergers Loop Engineering)
+- **LangGraph = Implementierungs-Framework** (State, Persistenz, HITL, Tracing)
+- **Graph Engineering = Shape-Vokabular** (Chain, Diamond, Router, Cycle als Design-Bausteine)
+
+Zusammen ergibt sich ein **3-Ebenen-Modell**:
+1. **Konzeption:** In Loops denken (Steinberger)
+2. **Design:** Shapes zeichnen (Kopadze)
+3. **Implementation:** Als LangGraph bauen (Harrison Chase)
+
+## Verwandte Konzepte
+
+- [[graph-based-agents.md]] — LangGraph als Implementierungs-Framework
+- [[agent-loops.md]] — Loop Engineering (ReAct-Pattern)
+- [[../../architecture/agent-orchestration.md]] — Übergeordnete Orchestrierungs-Patterns
+- [[../../architecture/model-routing.md]] — Model Routing als komplementäre Optimierung (richtiges Modell für jede Node)
+- [[../../tools/openclaw.md]] — OpenClaw als Agent-Plattform
+- [[ai-agents-2026.md]] — Gesamtentwicklung autonomer Agenten
+- [[../../../tools/model-routing.md]] — Cost-Saving Patterns mit Model-Split
+- [[../../concepts/llm/llm-model-catalog.md]] — Modell-Katalog für Node-Zuweisung
+
+## Quellen
+
+- @AnatoliKopadze (2026-07-25): Graph Engineering Guide — X-Thread (viral)
+- [[../../../../raw/xpost/2026-07-25_anatoli-kopadze-graph-engineering-guide.md]] (Raw Source)
+- [[graph-based-agents.md]] — Vergleich und Einordnung
+- [[agent-loops.md]] — Loop vs. Graph Abgrenzung
--- a/wiki/index.md
+++ b/wiki/index.md
@ -2,7 +2,7 @@

 *Auto-generated: 2026-07-07*

- *Letzte Aktualisierung: 2026-07-23 (82. Update — Logan Graham (Anthropic Frontier Red Team Lead) Fox Business Interview: Red-Teaming, weird behavior, Chip-Exportkontrollen, IP-Diebstahl, Governance-Standards. Raw: `raw/youtube/2026-07-23-anthropic-red-team-logan-graham.md`. Wiki-Updates: `concepts/anthropic-red-teaming-frontier-safety.md` (new) + `decisions/ai-governance-chip-export-controls.md` (new) + `people/logan-graham.md` (new). Log: 2026-07-23 ingest: anthropic-red-team-logan-graham.)*
+ *Letzte Aktualisierung: 2026-07-26 (83. Update — Anatoli Kopadze Graph Engineering Guide: 4 fundamentale Shapes + 10-Step Build Guide. Raw: `raw/xpost/2026-07-25_anatoli-kopadze-graph-engineering-guide.md`. Wiki-Updates: `concepts/agents/graph-engineering.md` (new). Log: 2026-07-26 ingest: anatoli-kopadze graph engineering guide.)*

 ## Architecture

@ -124,6 +124,7 @@
 | [AI Trading & Finance Hub](concepts/agents/ai-trading-hub.md) | **Hub-Page** für Trading-Cluster: Hype-Checks, Options, Tools, Policy | WMT-004 |
 | [Agent Memory Taxonomy — The Seven Kinds](concepts/agents/agent-memory-taxonomy.md) | Taxonomy of 7 agent memory types (working, semantic, episodic, procedural, retrieval, parametric, prospective) mit Open-Source-Repos. plur1bus-Einordnung: ✅ Semantic/Episodic/Retrieval, ⚠️ Procedural/Working, ❌ Prospective/Parametric. Key gap im Post: Consolidation & Forgetting — plur1bus's differentiator (GC+Decay, Merging, neverForget, Emotion-Tiers) | other/2026-07-02_agent-memory-taxonomy-seven-types.md |
 | [Graph-Based Agent Architecture (LangGraph)](concepts/agents/graph-based-agents.md) | Agenten als gerichteter Graph (Nodes=Aktionen, Edges=Übergänge). LangGraph: Persistence, HITL, Tracing, Cycles. Komplexer aber robuster als Loops. Konsens: "Denk in Loops, implementier als LangGraph" | xpost/2026-07-18_steipete-loops-vs-graphs.md + docs.langchain.com |
+| [Graph Engineering — 4 Fundamental Shapes](concepts/agents/graph-engineering.md) | Shape-Vokabular für Agent-Workflows: Chain (sequentiell), Diamond (parallel + Verifier), Router (Entscheidungsbaum), Cycle (kontrollierte Schleife). 10-Step Build-Guide. Ergänzt LangGraph um Design-Ebene | xpost/2026-07-25_anatoli-kopadze-graph-engineering-guide.md |

 ### Policy
 | Seite | Beschreibung | Quellen |
--- a/wiki/log.md
+++ b/wiki/log.md
@ -1495,3 +1495,16 @@ Bestehende `post-transformer-llm-architectures.md` bleibt als Vier-Säulen-Über
 - Forderung nach branchenweiten Test-Standards schließt ausländische + Open-Source-Modelle ein — direkt relevant für die Open-Weights-Debatte
 - Unternehmens-Empfehlung "nur Modelle mit nachvollziehbaren Sicherheitsprofilen" ist praktisch anwendbar
 **Subagent-Modell:** ollama/glm-5.2:cloud
+
+## [2026-07-26] Ingest | Anatoli Kopadze Graph Engineering Guide — 4 Fundamental Shapes + Build Guide
+
+**Type:** ingest | **Scope:** raw/xpost, wiki/concepts/agents (new), wiki/index, wiki/log
+**Source:** X-Thread von @AnatoliKopadze — https://x.com/AnatoliKopadze (25.07.2026, viral)
+**Trigger:** Subagent task: Wikify Graph Engineering Guide in Knowledge Base.
+**Actions:**
+- raw: `raw/xpost/2026-07-25_anatoli-kopadze-graph-engineering-guide.md` (created — 2.5 KB; Frontmatter [type: xpost, author: @AnatoliKopadze, is_thread: true, tags: graph-engineering, ai-agents, agent-architecture, workflows, orchestration, graph-shapes, parallel-execution, verification-nodes]. Content: Vollständiger Thread-Inhalt — Shape 0-4, 10-Step Guide, Key Insight, Cross-Refs)
+- wiki (NEW): `concepts/agents/graph-engineering.md` (created — 7.4 KB; Frontmatter [sources, tags, people: anatoli-kopadze]. Sections: Definition, Shape 0 (Basics), Shape 1 (Chain), Shape 2 (Diamond), Shape 3 (Router), Shape 4 (Cycle), Step-by-Step Build Guide, Vergleichstabelle, Verhältnis zu Loops & LangGraph (3-Ebenen-Modell), 8 Cross-Refs)
+- wiki: `index.md` (updated — Header auf "83. Update", neuer Agents-Eintrag für Graph Engineering, neuer Raw-Sources-Eintrag)
+- log: this entry
+**Hector-Hauptthese:** Kopadzes Thread füllt eine Lücke in der bestehenden Graph-vs-Loop-Debatte. Während Steinberger das konzeptionelle Loop-Engineering und LangGraph/Chat das Implementierungs-Framework liefern, fehlte ein **Shape-Vokabular** — eine Design-Sprache, mit der man Workflows vor der Implementierung skizzieren kann. Kopadzes 4 Shapes (Chain, Diamond, Router, Cycle) sind genau das. Der Diamond als "Workhorse" ist besonders wertvoll: er formalisiert das Fan-Out/Verifier-Pattern, das in der Praxis die größte Hebelwirkung hat. Der 10-Step Guide ist konkret genug für den Einstieg, aber allgemein genug für jeden Graph-Typ. Die Key Insight ("Die 90%-Leute tippen keine Prompts — sie lassen parallele Agenten in Graphen laufen") fasst den Paradigmenwechsel präzise zusammen.
+**Subagent-Modell:** openrouter/deepseek/deepseek-v4-flash