diff --git a/raw/xpost/2026-07-25_anatoli-kopadze-graph-engineering-guide.md b/raw/xpost/2026-07-25_anatoli-kopadze-graph-engineering-guide.md new file mode 100644 index 0000000..fedb104 --- /dev/null +++ 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) \ No newline at end of file diff --git a/wiki/concepts/agents/graph-engineering.md b/wiki/concepts/agents/graph-engineering.md new file mode 100644 index 0000000..3ce680f --- /dev/null +++ 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 \ No newline at end of file diff --git a/wiki/index.md b/wiki/index.md index 126abcf..c9305ef 100644 --- 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 | diff --git a/wiki/log.md b/wiki/log.md index 6986c7d..d23e6f1 100644 --- 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