ingest(analysis): ruediger agent architecture triade (steinberger-kopadze-langgraph)

raw/log.md

@@ -0,0 +1 @@
+- 2026-07-24 ingest: clawcast-folge5-sqlite-pages (YouTube zSkI2vJlmbs, ClawCast 5, Kevin Lin/OpenAI + Patrick Erichsen). SQLite-Refactor (JSONL→SQLite, two-level layout), Pages-Konzept (Agent-Generated Widgets, Canvas-Plugin, A2UI), Control UI Overhaul, Onboarding, Stable Channel. Wiki: architecture/sqlite-pages-7.2.md. Raw: raw/youtube/2026-07-22_clawcast-folge5-sqlite-pages.md + clawcast-folge5-sqlite-pages-excerpt.md + clawcast-folge5-research-summary.md.

raw/xpost/2026-07-26_ruediger-agent-architecture-triade.md

@@ -0,0 +1,79 @@
+---
+type: analysis/synthesis
+source_url: "https://t.me/c/-1003839640481/13"
+retrieved: 2026-07-26
+author: "Rüdiger"
+source_group: "OME-Gruppe Topic 13"
+title: "Die Drei-Säulen-Triade der Agenten-Architektur: Steinberger, Kopadze, LangGraph"
+tags: [agent-architecture, steinberger, kopadze, langgraph, diamond-pattern, loop-engineering, shape-vocabulary, design-patterns, orchestration, agent-topology]
+people: [peter-steinberger, harrison-chase]
+institutions: [langchain]
+---
+
+# Die Drei-Säulen-Triade der Agenten-Architektur: Steinberger, Kopadze, LangGraph
+
+**Author:** Rüdiger
+**Posted:** 2026-07-26 (OME-Gruppe Topic 13)
+**Type:** Analysis/Synthesis
+
+## Die Drei-Säulen-Triade der Agenten-Architektur
+
+- **[Conceptual] Steinberger** → Loop-Engineering (WANN & WARUM kontrollieren?)
+- **[Architectural] Kopadze** → Shape-Vokabular (WELCHE FORM nutzt das System?)
+- **[Technical] LangGraph** → Implementation (WIE wird es verdrahtet?)
+
+### 1. Steinberger = Loop-Engineering (Konzeptionell)
+
+- **Perspektive:** Steinberger addressiert die Dynamik und Metrik. Loop-Engineering stellt Fragen wie: Wann bricht ein Loop ab? Wie verhindern wir Halluzinationen in der Feedback-Schleife? Welcher Threshold entscheidet über "gut genug"?
+- **Rolle:** Es leistet die wissenschaftliche/konzeptionelle Grundlagenarbeit für die Selbstkorrektur von LLMs (Self-Correction, Reflection, Grounding).
+- **Problem ohne die anderen:** Reines Loop-Engineering erklärt dir, wie ein Verifier-Loop mathematisch und logisch stabil bleibt, aber nicht, wie du 5 verschiedene Spezialagenten miteinander arrangierst.
+
+### 2. LangGraph = Implementation (Infrastrukturell)
+
+- **Perspektive:** Das Framework-Rückgrat. Es bietet Python/TypeScript-Primitive für State, Nodes, Edges, Checkpointing, Time-Travel und Routing.
+- **Rolle:** Es stellt sicher, dass der Zustand (State) deterministisch durch gerichtete Graphen fließt.
+- **Problem ohne die anderen:** 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.
+
+### 3. Kopadze = Shape-Vokabular (Design-Patterns)
+
+- **Perspektive:** Die fehlende Semantik. Kopadze liefert die Architektur-Muster (Shapes), die beschreiben, wie Information durch den Graph strömen soll.
+- **Rolle:** Ähnlich wie die Gang of Four (GoF) in der objektorientierten Programmierung (Design Patterns wie Singleton, Factory, Strategy) gibt Kopadze dem Agenten-Design eine abstrakte, aber präzise Sprache: Parallel Fan-Out, Diamond, Hierarchical Router, Cyclic Evaluator.
+- **Warum Kopadze die Lücke füllt:** Er übersetzt das abstrakte Loop-Engineering von Steinberger in Topologie, die sich direkt in LangGraph-Graphen gießen lässt.
+
+## Warum das "Diamond Pattern" das mächtigste Workhorse ist
+
+Das Diamond-Pattern (Fan-Out + Verifier / Join) löst das fundamentale Dilemma monolithischer LLM-Prompts.
+
+### Topologie
+
+```
+[Router/Splitting] ──► [Sub-Agent A: Task 1] ──┐
+                    ──► [Sub-Agent B: Task 2] ──┼─► [Evaluator/Verifier] ──► [Output/Retry]
+                    ──► [Sub-Agent C: Task 3] ──┘
+```
+
+### Warum dieses Pattern im Alltag dominiert
+
+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).
+
+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.
+
+### Fazit
+
+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.
+
+## Verwandte Wiki-Seiten
+
+- [[../../wiki/concepts/agents/graph-based-agents.md]] — Graph-basierte Agenten (LangGraph)
+- [[../../wiki/concepts/agents/agent-loops.md]] — Loop-Engineering (Steinberger)
+- [[../../wiki/concepts/agents/ai-agents-2026.md]] — AI Agents 2026 Übersicht
+- [[../../wiki/architecture/agent-orchestration.md]] — Agenten-Orchestrierung
+
+## Quellen
+
+- X-Post @steipete: "Are we still talking loops or did we shift to graphs yet?" — https://x.com/steipete/status/2078277297791189132
+- LangGraph Overview: https://docs.langchain.com/oss/python/langgraph/overview

raw/youtube/2026-07-22_clawcast-folge5-sqlite-pages.md

@@ -0,0 +1,46 @@
+---
+source: youtube
+video_id: zSkI2vJlmbs
+url: https://www.youtube.com/watch?v=zSkI2vJlmbs
+title: "Der OpenClaw-Podcast – Der ClawCast – Folge 5"
+published: 2026-07-22
+duration: ~30min
+participants: Kevin (OpenAI, OpenClaw Maintainer), Patrick (OpenClaw Dev Team/Foundation)
+ingested_by: hector
+ingested_at: 2026-07-24
+---
+
+# ClawCast Folge 5 — Zusammenfassung
+
+## Kevins Rolle bei OpenAI
+- Vor ~2 Jahren zu OpenAI, startete im Info-Team
+- Leitete Connector-Produkte (jetzt "Plugins" in ChatGPT: Gmail, Notion etc.)
+- Vor ~2 Monaten mit Peter zusammen Team für OpenClaw bei OpenAI gegründet — Enterprise-Rollout
+- Gleichzeitig OpenClaw-Maintainer
+
+## OpenClaw = harness-agnostisch
+- OpenClaw ist kein Harness, sondern End-to-End-Plattform
+- Harness (z.B. Codex) = "der Motor im Auto"
+- OpenClaw = Orchestrator: sagt Codex, was es tun soll
+- Bei OpenAI-Modellen läuft Codex App Server im Hintergrund als Harness
+
+## GPT-5.6
+- Long-Horizon-Tasks: arbeitet persistenter bis zum Ziel
+- Token-effizient: trotz mehr Compute weniger Tokens bei komplexen Projekten
+- Computer Use & Multi-Agent
+- OpenAI-Mitarbeiter "deprimiert", weil Modell ihre Arbeit one-shoten könnte
+
+## OpenClaw 7.2 (Beta 4, Release diese Woche/nächste Tage)
+- **Control UI massiv überarbeitet** — für Daily Driving beim Coden
+- **Pages-Konzept**: Agenten generieren Widgets → auf persistenten Seiten gepinnt (z.B. Excalidraw-Widgets, künftig MCP Apps)
+- **Onboarding**: Erkennt API-Keys automatisch, verdrahtet Modelle/Harnesses — auf leerem VPS wird automatisch lokales Modell (Gemma 4) gezogen
+- **SQLite-Refactor**: Ersetzt statische JSONL-Files (die nach 3 Monaten auf 200MB aufblähten) → Portabilität
+
+## Stable Release (statt LTS)
+- Monatliche stabile Version — nur Security- & Reliability-Fixes, keine Feature-Updates
+- Für Unternehmen mit längeren Upgrade-Zyklen
+- Ankündigung Ende dieser Woche oder nächste Woche
+
+## Kevins #1 Verbesserungspunkt
+- "Easier to get started" — Packaging und First-Time-Experience sind entscheidend, nicht technische Sophistication
+- "Du gibst jemandem einen Agenten und er fragt: Was mache ich damit?"

raw/youtube/clawcast-folge5-research-summary.md

@@ -0,0 +1,60 @@
+# ClawCast Folge 5 — Recherche-Zusammenfassung
+
+**Video:** ClawCast Episode 5 (`zSkI2vJlmbs`) · Kevin Lin (OpenAI), Hannes Rudolph, Patrick Erichsen  
+**Thema:** OpenClaw 7.2 Preview — SQLite, UI, Onboarding, Orchestrierung
+
+---
+
+## 1. Podcast-Aussagen (aus Video-Beschreibung)
+
+### SQLite-Refactor
+Zentrales Thema: **Umstellung von JSONL-Dateien auf SQLite**. Die OpenClaw-Docs spezifizieren eine zwei-Level-Architektur — globale DB (`state/openclaw.sqlite`) als Control-Plane, pro-Agent-DB (`openclaw-agent.sqlite`) als Data-Plane. Config bleibt file-backed (`openclaw.json`), Runtime-Auth wandert in SQLite. Legacy-JSONL wird zu Doctor-Migration-Input.
+
+### Neue UI / Pages
+**"Neue Benutzeroberfläche für den täglichen Einsatz von Agenten"** — pinnbare Sessions, Custom Groups, Split View für parallele Konversationen, Command Palette (⌘K), Activity Tab. Canvas-Panel für agent-generierte UIs (HTML/CSS/JS, A2UI), als experimentelles Bundle-Plugin.
+
+### Onboarding
+**"Automatische Erkennung von API-Schlüsseln und Erstellung eines lokalen Modells"**: Sucht nach Claude Code, Codex, Gemini CLI-Logins oder `OPENAI_API_KEY`/`ANTHROPIC_API_KEY`, testet live mit Completion-Call, fällt bei Misserfolg zurück. Default-Tools-Profil: `"coding"`.
+
+### Orchestrierung & Enterprise
+OpenClaw als Orchestrator, der Codierung an Codex delegiert. Menschlicher Geschmack bleibt entscheidend für Wartbarkeit. Neue monatliche stabile Version für Unternehmen.
+
+---
+
+## 2. OpenClaw-Docs dazu
+
+### SQLite (`/app/docs/refactor/database-first.md`)
+- Status: Sessions/Transcripts/Cron/Tasks/Plugins = `clean`; Memory/Backup = `sqlite-runtime`
+- `node:sqlite` direkt, WAL-Reset-safe (Node 22.22.3+, 24.15+)
+- Hartes Verbot von Transcript-Locators; Identität = `{agentId, sessionId}`
+- VFS über `vfs_entries`-Tabelle, pro-Agent isoliert
+
+### Control UI (`/app/docs/web/control-ui.md`)
+- Vite+Lit SPA, 21 Sprachen, Split View, Session-Pinning, Operator Terminal
+- Canvas experimentell (`/app/docs/refactor/canvas.md`): `extensions/canvas/` als Bundle-Plugin
+
+### Onboarding (`/app/docs/start/`, `wizard-cli-reference.md`)
+- Auto-Detection mit Live-Test, Default: MiniMax-M3 (hosted), `gpt-5.6-sol` (Codex)
+
+---
+
+## 3. Perspektivische Bedeutung
+
+### Für User
+Onboarding erkennt API-Keys automatisch und testet sie live. Split View und Pinning machen Multi-Session-Work übersichtlich. Sofort funktionsfähige Inferenz ohne Manual-Setup.
+
+### Für Entwickler
+SQLite eliminiert JSONL-Session-Files zugunsten typisierter relationaler Tabellen. Vereinfachte Backups (ein Archiv), pro-Agent-Isolation, FTS-fähig. Canvas als Plugin zeigt: Core wird schlank, Features plugin-isiert. A2UI erlaubt agent-generierte UIs.
+
+### Für Enterprise
+Monatliche stabile Version = vorhersehbare Release-Zyklen. SQLite-Zentralisierung: typisierte Tabellen (Audit), SQLite-Snapshots (Backup), Control/Data-Plane-Trennung (Skalierung für viele Agenten).
+
+---
+
+## Fazit
+
+ClawCast 5 markiert den Übergang vom Chat-Tool zur orchestrierten Agent-Plattform. SQLite-First, Control-UI-Overhaul und Auto-Onboarding sind in den Docs weitgehend `clean` implementiert. Version 7.2 konsolidiert diese Refactors. Podcast = Narrativ, Docs = technische Substanz.
+
+---
+
+*Quellen: YouTube-Beschreibung (ytInitialData), 13 OpenClaw-Docs aus `/app/docs/`. Transkript serverseitig nicht abrufbar (YouTube Bot-Protection).*

raw/youtube/clawcast-folge5-sqlite-pages-excerpt.md

@@ -0,0 +1,210 @@
+# ClawCast Folge 5 — Recherche-Extrakt: SQLite, Pages, Control UI, Onboarding
+
+**Video:** The OpenClaw Podcast - The ClawCast - Episode 5  
+**YouTube-ID:** `zSkI2vJlmbs`  
+**Kanal:** https://www.youtube.com/@OpenClawYT  
+**Gäste:** Kevin Lin (OpenAI), Moderator: Hannes Rudolph, Co-Moderator: Patrick Erichsen  
+**Aufzeichnungsdatum:** vor 2026-06-30 (Release v2026.6.11)  
+**Sprache:** Deutsch (Beschreibung), Video vermutlich Englisch
+
+> ⚠️ **Transkript-Verfügbarkeit:** Das YouTube-Transkript konnte serverseitig nicht abgerufen werden (YouTube blockt alle Anfragen mit "LOGIN_REQUIRED" / "Sign in to confirm you're not a bot"). Die folgenden Passagen basieren auf der **offiziellen Video-Beschreibung** (die detailliert ist) und den **OpenClaw-Docs** (`/app/docs/`), die dieselben Themen dokumentieren.
+
+---
+
+## 1. Video-Beschreibung (Originaltext)
+
+> In dieser Folge des offiziellen OpenClaw-Podcasts „The ClawCast" sprechen Moderator Hannes Rudolph, OpenClaw Community Manager, und Co-Moderator Patrick Erichsen, OpenClaw-Entwickler, mit Kevin Lin von OpenAI über die bevorstehende OpenClaw-Version 7.2, die neue Benutzeroberfläche für den täglichen Einsatz von Agenten und die Herausforderungen einer erfolgreichen Zusammenarbeit mit einem Agenten, anstatt ihm lediglich Aufgaben zuzuweisen.
+>
+> Das Gespräch behandelt die Nutzung von OpenClaw als Orchestrator, der die Codierung an Codex delegiert, die Bedeutung menschlichen Geschmacks und Urteilsvermögens für die Wartbarkeit von Code, die Schwächen aktueller Spitzenmodelle, das überarbeitete Agenten-Onboarding (automatische Erkennung von API-Schlüsseln und Erstellung eines lokalen Modells für einen schnellen Einstieg), die Umstellung von JSONL-Dateien auf SQLite sowie die neue monatliche „stabile Version" für Unternehmen, die längere Aktualisierungsintervalle wünschen.
+>
+> **Themen:** OpenClaw als Orchestrator mit Codex-Delegation, menschlicher Geschmack und Urteilsvermögen, Grenzen moderner Modelle, überarbeitetes Agenten-Onboarding, JSONL→SQLite, monatliche stabile Version.
+
+---
+
+## 2. SQLite-Refactor — JSONL-Dateien → SQLite
+
+### Aus der Video-Beschreibung
+- **Umstellung von JSONL-Dateien auf SQLite** als eines der Hauptthemen des Podcasts
+- Die Beschreibung nennt es neben dem Onboarding als eine der zentralen technischen Veränderungen in Version 7.2
+
+### Aus den OpenClaw-Docs (`/app/docs/refactor/database-first.md`)
+
+#### Architektur-Entscheidung
+- **Zwei-Level SQLite-Layout:**
+  - **Globale Datenbank:** `~/.openclaw/state/openclaw.sqlite` (Control-Plane: Agent Discovery, Gateway State, Pairing, Device/Node State, Task/Flow Ledgers, Plugin State, Scheduler, Backup)
+  - **Agent-Datenbank:** eine SQLite-DB pro Agent unter `agents/<agentId>/agent/openclaw-agent.sqlite` (Data-Plane: Session-Metadaten, Transcript Events, VFS, Artifacts, Cache)
+- **Konfiguration bleibt file-backed:** `openclaw.json` bleibt außerhalb der Datenbank
+- **Runtime-Auth-Profiles** wandern nach SQLite; externe Provider/CLI-Credential-Files bleiben owner-managed
+
+#### Bloat-Problem / Warum SQLite
+- Legacy `sessions.json`, Transcript-JSONL, `.jsonl.lock`, Pruning, Truncation → nur noch Doctor-Migration-Inputs
+- `transcriptLocator` und JSONL-Dateipfade sind **keine Runtime-Identity** mehr
+- Transcript-Identität ist jetzt: `{agentId, sessionId}` — typisiert, relational
+- `sqlite-transcript://...` ist explizit verboten als Runtime/Protocol-Identity
+- Sämtliche Runtime-Pfade (Startup, Reply, Compaction, Reset, Recovery, Diagnostics, TTS, Memory, Subagents, Plugins, Protocol, Hooks) verwenden `{agentId, sessionId}`
+
+#### Portabilität
+- `node:sqlite` direkt (kein externer SQLite-Client nötig)
+- WAL-Reset-safe Node-Runtime erforderlich: 22.22.3+, 24.15+, oder 25.9+
+- Backup: SQLite-Snapshots statt live WAL/SHM-Sidecars → ein Archiv-File
+- Per-Agent-Datenbanken für isolierte Agent-Workspaces, Transcripts und binäre Scratch-Daten
+
+#### Aktueller Stand (laut Doc)
+- Sessions: `clean` für Runtime
+- Transcripts: `clean` für Runtime
+- PI embedded runner: `clean`
+- Cron: `clean`
+- Task registry: `clean`
+- Plugin state: `clean`
+- Memory: `sqlite-runtime`
+- Backup: `sqlite-runtime`
+- Doctor migration: `migrating` (intentional)
+
+#### Canvas als Plugin
+- Canvas wird als **experimentelles Bundle-Plugin** behandelt, nicht als Core-Feature (`/app/docs/refactor/canvas.md`)
+- `extensions/canvas/` owns: Plugin-Manifest, Agent-Tool-Registration, Node-Invoke-Policy, Canvas-Host, A2UI-Runtime, Document-Creation, CLI
+
+---
+
+## 3. Pages-Konzept — Agent-Generated UI, Widgets, Excalidraw, MCP Apps
+
+### Aus der Video-Beschreibung
+- **"Neue Benutzeroberfläche für den täglichen Einsatz von Agenten"** als Hauptthema
+- "Herausforderungen einer erfolgreichen Zusammenarbeit mit einem Agenten, anstatt ihm lediglich Aufgaben zuzuweisen"
+
+### Aus den OpenClaw-Docs
+
+#### Control UI — Pinnbare Sessions & Pages
+- Sessions können **gepinnt** werden (Pinned, Custom Groups, Ungrouped)
+- **Session-Gruppierung:** Channel, Kind, Agent, Date, oder Custom Groups via `sessions.patch { category }`
+- **Command Palette** (⌘K): Suche über Sessions, Pages, Commands
+- **All Sessions Page:** exhaustive searchable list with filters
+- **Split View:** Mehrere Sessions nebeneinander, drag-and-drop aus Sidebar
+- **Embeds:** `[embed url="..."]` shortcode für gehostete Web-Inhalte (iframe sandbox)
+- **Canvas-Panel:** Agent-gesteuerter visueller Workspace (HTML/CSS/JS, A2UI) über `openclaw-canvas://<session>/<path>`
+- **A2UI v0.8:** Server-to-client Messages (`beginRendering`, `surfaceUpdate`, `dataModelUpdate`, `deleteSurface`)
+- **Excalidraw:** Community-Skill "Excalidraw diagram generator" von @swiftlysingh (ClawHub)
+
+#### Canvas — Agent-Generated UI
+- Agent kann Canvas-Panel steuern: `present`, `navigate`, `eval`, `snapshot`
+- Canvas-Dateien unter `~/Library/Application Support/OpenClaw/canvas/<session>/...`
+- Auto-Reload bei Dateiänderungen
+- A2UI-Push für strukturierte UI-Komponenten
+- Deep Links: `openclaw://agent?message=...` für Agent-Triggers aus Canvas
+
+#### MCP Apps
+- Dedicated MCP-Settings-Page in Control UI für `mcp.servers`
+- `openclaw mcp doctor --probe`, `openclaw mcp status --verbose`, `openclaw mcp reload`
+- Plugin-State in SQLite: `plugin_state_entries`, `plugin_blob_entries`
+
+---
+
+## 4. Control UI Overhaul
+
+### Aus der Video-Beschreibung
+- "Neue Benutzeroberfläche für den täglichen Einsatz" — Version 7.2
+- "Bevorstehende OpenClaw-Version 7.2" mit Fokus auf UI für tägliche Agenten-Nutzung
+
+### Aus den OpenClaw-Docs (`/app/docs/web/control-ui.md`, `/app/docs/web/index.md`)
+
+#### Control UI Architecture
+- **Vite + Lit** Single-Page-App, vom Gateway-Port geserved
+- Default: `http://<host>:18789/`
+- Spricht direkt zum Gateway-WebSocket
+- Auth: Token, Password, Tailscale Serve Identity, Trusted-Proxy
+
+#### Neue Features (v2026.6.11+)
+- **Session-Pinning & Gruppierung:** Pinned sessions, Custom Groups, Drag-and-Drop
+- **Split View:** Mehrere Chat-Panes mit eigenem Session/Transcript/Composer
+- **Activity Tab:** Ephemeral browser-local Tool-Activity-Summaries (Redaction-first)
+- **Operator Terminal:** Dockable PTY (`gateway.terminal.enabled`), `Ctrl+backtick`, überlebt Disconnects
+- **Web Push:** VAPID-Keys, `push.web.subscribe/unsubscribe/test`
+- **Embeds:** Hosted web content inline mit `[embed]` shortcode, konfigurierbare sandbox policies
+- **Command Palette (⌘K):** Session-Suche über Agents, filtert interne Child/Cron-Rows
+- **MCP Page:** Dedicated Operator-View für MCP-Server
+- **Usage Dashboard:** Token/Cost-Analysis, Provider-Karten
+- **GitHub Link Previews:** Hover über GitHub Issue/PR-Links → State, Title, Author, Activity
+- **Personal Identity:** Browser-local Display Name + Avatar
+- **Themes:** Claw, Knot, Dash + tweakcn-Import
+- **Language Support:** 21 Locales (inkl. `de`)
+
+---
+
+## 5. Onboarding — API-Key-Erkennung, Auto-Setup
+
+### Aus der Video-Beschreibung
+- **"Überarbeitetes Agenten-Onboarding (automatische Erkennung von API-Schlüsseln und Erstellung eines lokalen Modells für einen schnellen Einstieg)"**
+
+### Aus den OpenClaw-Docs (`/app/docs/start/onboarding.md`, `/app/docs/start/wizard-cli-reference.md`)
+
+#### Auto-Detection
+- Onboarding sucht nach: Claude Code, Codex, oder Gemini CLI-Login, oder `OPENAI_API_KEY` / `ANTHROPIC_API_KEY`
+- **Live-Test:** Bestes gefundenes Setup wird mit echtem Completion-Call getestet
+- Bei Failure: automatisch nächstes Option probieren, Fehlergrund anzeigen
+- Bei mehreren Optionen: Umschalten möglich, bevor man weitergeht
+
+#### Manual Fallback
+- Wenn nichts gefunden wird: Manual Key/Token-Picker lädt Gateway's aktive Text-Inference Provider-Plugins
+- Provider liefert Starter-Model + Config
+- Live-Test vor Speicherung der Auth-Profile
+- "Next" bleibt locked bis ein Backend funktioniert
+
+#### Default Model
+- Hosted Default: `MiniMax-M3`
+- OpenAI Code Subscription (OAuth): `openai/gpt-5.6-sol` via Codex Runtime
+- OpenAI API Key: `openai/gpt-5.6` (bare → Sol Tier)
+- Anthropic: `ANTHROPIC_API_KEY` oder Claude CLI-Reuse
+- xAI: Grok OAuth für SuperGrok/X Premium
+
+#### Default Tools Profile
+- Neue Onboarding-Configs: `tools.profile: "coding"` (nicht unrestricted `full`)
+- Sicherheit: Filesystem/Runtime-Tools ohne `full`-Profile
+
+#### Weitere Onboarding-Steps
+- Workspace: Default `~/.openclaw/workspace`
+- Gateway: Port, Bind, Auth, Tailscale
+- Channels: WhatsApp (QR), Telegram (Bot Token), Discord (Bot Token), Google Chat, Mattermost, Signal, iMessage
+- Web Search: Brave, DuckDuckGo, Exa, Firecrawl, Gemini, Grok, Kimi, MiniMax, Ollama, Perplexity, SearXNG, Tavily
+- Daemon: macOS LaunchAgent, Linux systemd, Windows Scheduled Task
+- Health Check: `openclaw health`, `openclaw status --deep`
+- Skills: npm/pnpm/bun, install optional dependencies
+
+#### macOS App Onboarding
+- TCC Permissions: Automation, Notifications, Accessibility, Screen Recording, Microphone, Speech, Camera, Location
+- Dedicated Onboarding-Chat (separate Session für Agent-Intro)
+- Security Trust Model: Default = Personal Agent (one trusted operator)
+
+---
+
+## 6. Cross-Reference: Podcast-Themen ↔ OpenClaw-Docs
+
+| Podcast-Thema | OpenClaw-Doc | Status |
+|---|---|---|
+| JSONL → SQLite | `/app/docs/refactor/database-first.md` | `clean` für Runtime, Doctor-Migration läuft |
+| Neue UI / Pages | `/app/docs/web/control-ui.md` | Vite+Lit, Split View, Pinning, Groups |
+| Agent-Generated UI | `/app/docs/platforms/mac/canvas.md` | Canvas-Panel, A2UI v0.8 |
+| Canvas als Plugin | `/app/docs/refactor/canvas.md` | `extensions/canvas/`, experimental |
+| Onboarding Auto-Detect | `/app/docs/start/onboarding.md` | CLI-Login + API-Key + Live-Test |
+| Onboarding Default Model | `/app/docs/start/wizard-cli-reference.md` | MiniMax-M3 hosted, gpt-5.6-sol Codex |
+| Monatl. stabile Version | Release v2026.6.11 Notes | "Reliability fixes" als stabilere Version |
+| Codex-Delegation | `/app/docs/start/wizard-cli-reference.md` | Codex Runtime, `openai/gpt-5.6-sol` |
+| Excalidraw | ClawHub Showcase | @swiftlysingh Community-Skill |
+| MCP Apps | `/app/docs/web/control-ui.md` MCP Page | `mcp.servers` config, `openclaw mcp` CLI |
+
+---
+
+## Quellen
+
+1. YouTube Video-Beschreibung (via `ytInitialData` aus YouTube-Page-HTML, `https://www.youtube.com/watch?v=zSkI2vJlmbs`)
+2. `/app/docs/refactor/database-first.md` — Database-First State Refactor Plan
+3. `/app/docs/refactor/canvas.md` — Canvas Plugin Refactor
+4. `/app/docs/platforms/mac/canvas.md` — Canvas macOS Panel
+5. `/app/docs/web/control-ui.md` — Control UI Documentation
+6. `/app/docs/web/index.md` — Web Surfaces Overview
+7. `/app/docs/web/dashboard.md` — Dashboard Auth
+8. `/app/docs/start/onboarding.md` — macOS App Onboarding
+9. `/app/docs/start/wizard-cli-reference.md` — CLI Onboarding Reference
+10. `/app/docs/start/onboarding-overview.md` — Onboarding Overview
+11. `/app/docs/releases/2026.6.11.md` — Release Notes v2026.6.11
+12. `/app/docs/reference/application-modernization-plan.md` — Modernization Plan
+13. `/app/docs/start/showcase.md` — Community Showcase

wiki/architecture/sqlite-pages-7.2.md

@@ -0,0 +1,79 @@
+---
+title: "SQLite-Refactor & Pages-Konzept — OpenClaw 7.2"
+category: architecture
+tags: [openclaw, sqlite, pages, ui, architecture, 7.2]
+source: clawcast-folge-5
+created: 2026-07-24
+---
+
+# SQLite-Refactor & Pages-Konzept — Perspektivische Analyse
+
+## Kontext
+
+ClawCast Folge 5 (22.07.2026) mit Kevin (OpenAI, OpenClaw-Maintainer) und Patrick (OpenClaw Dev Team). Ankündigung für OpenClaw 7.2 (Beta 4, Release Ende Juli 2026).
+
+## SQLite-Refactor
+
+### Status Quo
+- Transkripte und Session-Daten liegen als `transcript.jsonl` (append-only JSONL) im State-Directory
+- Struktur: `~/.openclaw/transcripts/YYYY-MM-DD/<session>/transcript.jsonl`
+- Pro Session eine JSONL-Datei — wächst ungebremst mit jedem Turn
+- Nach 3 Monaten Betriebszeit: 200MB+ pro aktiver Session
+- JSONL ist ineffizient für Queries, Suchen, GC — kein Index, kein Schema, kein Transactional Safety
+
+### Was der Refactor bringt
+- **Migration JSONL → SQLite**: Session-Transkripte werden in SQLite-Tabellen gespeichert statt in flachen JSONL-Files
+- **Bereits vorhanden**: SQLite wird für per-agent runtime state verwendet (`agents/<agentId>/agent/openclaw-agent.sqlite`) — Backup nutzt bereits `VACUUM INTO` für sichere Snapshots
+- **Auf den Transkript-Store erweitert**: Dieselbe Infrastruktur wird auf Session-Transkripte ausgeweitet
+
+### Perspektivische Bedeutung
+
+1. **Portabilität**: Eine `.sqlite`-Datei pro Session/Agent statt Tausender JSONL-Fragments. Kopierbar, migration-fähig, inspect-fähig.
+2. **Query-fähig**: SQL-Queries statt `grep`/`awk` auf JSONL. Transkript-Suche, Message-Filterung, Zeitbereich-Queries — alles index-basiert.
+3. **GC & Compression**: `VACUUM`, WAL-Checkpointing, Row-Level-Deletion statt "ganze Datei löschen oder behalten". Alte Turns können selektiv bereinigt werden.
+4. **Transactional Safety**: ACID-Transaktionen — kein halb geschriebener Turn bei Crash, kein korrupter JSONL-Eintrag.
+5. **Performance**: Index-basierte Lookups statt Full-Text-Scan. Besonders relevant bei langen Sessions (200MB+).
+6. **Enterprise-Ready**: Backup-Mechanismus (VACUUM INTO) bereits etabliert. SQLite ist die Standard-Einbettungs-DB für Enterprise-Anwendungen.
+
+### Was sich für User ändert
+- **Kein manuelles JSONL-Cleanup mehr** — SQLite kümmert sich um GC
+- **Schnellere Session-Loads** — nur relevante Rows werden geladen, nicht die ganze Datei
+- **Bessere Backup-Story** — eine Datei pro Agent, nicht Tausende Fragmente
+- **Tooling**: `sqlite3` CLI reicht für Inspektion, keine JSONL-Parser nötig
+
+## Pages-Konzept
+
+### Status Quo
+- Control UI: Chat, Activity Tab, Split View, Sessions-Liste, Config-Editor
+- Canvas (macOS) als Preview-Feature
+- Keine persistenten Agent-Generated-UI-Widgets
+- Agent-Output ist primär Text + Tool-Cards — flüchtig, nicht pinnbar
+
+### Was das Pages-Konzept bringt
+- **Agent-Generated Widgets**: Agenten generieren UI-Widgets (Excalidraw-Diagramme, Code-Snippets, Task-Boards, Metriken)
+- **Persistente Seiten**: Widgets werden auf Seiten gepinnt — überleben Session-Ende
+- **MCP Apps als Widget-Quelle**: Künftig können MCP-Server UI-Widgets beisteuern — Drittanbieter-Ecosystem
+
+### Perspektivische Bedeutung
+
+1. **OpenClaw wird vom Chat-Interface zum Agent-Generated-Dashboard**: Der Agent baut sich seine eigene UI basierend auf dem Task. Nicht mehr nur "Antworten lesen" — sondern "Dashboard betrachten".
+2. **Multi-Modal-UI**: Excalidraw für Diagramme, Code-Widgets für Snippets, Task-Boards für Projekt-Tracking, Metriken-Widgets für Monitoring — alles auf einer Seite.
+3. **MCP-Ecosystem**: Jeder MCP-Server kann ein Widget beisteuern. Das öffnet den Markt für Drittanbieter-UIs — ähnlich wie Notion-Embeds oder Obsidian-Canvas-Plugins.
+4. **Enterprise-Ready**: Persistente Dashboards für Teams — nicht nur flüchtige Chat-Sessions. Ein Team kann eine "Seite" haben, die der Agent kontinuierlich pflegt.
+5. **Identitätsstiftend**: Das ist die Eigenleistung von OpenClaw gegenüber reinen Harnesses (Codex). Harness = Motor. OpenClaw = Auto + Dashboard + Navigation. Pages sind das UX-Differenzierungsmerkmal.
+
+### Was sich für User ändert
+- **Agent-Output wird greifbar**: Statt Text im Chat-Verlauf zu suchen, wird das Ergebnis auf einer Seite gepinnt
+- **Kontinuierliche Projektdashboards**: Agent pflegt eine Seite mit aktuellem Status, Diagrammen, Tasks
+- **Drittanbieter-Widgets**: MCP-Server liefern nicht nur Tool-Results, sondern auch UI-Komponenten
+
+## Querverweis: Stable Channel
+
+- Monatliche stabile Version — nur Security- & Reliability-Fixes
+- Für Enterprise mit längeren Upgrade-Zyklen
+- Ankündigung Ende Juli 2026
+- Siehe auch: [ClawCast Folge 5 Raw](../raw/youtube/2026-07-22_clawcast-folge5-sqlite-pages.md)
+
+## Fazit
+
+SQLite-Refactor und Pages-Konzept sind die beiden architektonischen Schritte, die OpenClaw von einem "Chat-basierten Agent-Runner" zu einer "Agent-Plattform mit persistenter UI und Enterprise-Grade Storage" machen. SQLite löst das Storage-Problem (JSONL-Bloat, GC, Portabilität), Pages löst das UI-Problem (flüchtige Chat-Outputs → persistente Agent-Generated-Dashboards). Beide zusammen machen OpenClaw Enterprise-ready.

wiki/concepts/agents/architecture-triade.md

@@ -0,0 +1,148 @@
+---
+created: 2026-07-26
+updated: 2026-07-26
+sources:
+  - xpost/2026-07-26_ruediger-agent-architecture-triade.md
+  - xpost/2026-07-18_steipete-loops-vs-graphs.md
+tags: [concept, agents, architecture, steinberger, kopadze, langgraph, diamond-pattern, loop-engineering, shape-vocabulary, design-patterns, orchestration, agent-topology]
+people: [peter-steinberger, harrison-chase]
+institutions: [langchain]
+---
+
+# Architecture Triade: Steinberger, Kopadze, LangGraph
+
+> *"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:
+
+| Säule | Perspektive | Kernfrage | Analogie in OOP |
+|-------|-------------|-----------|-----------------|
+| **[Conceptual] Steinberger** | Loop-Engineering | WANN & WARUM kontrollieren? | Algorithmen |
+| **[Architectural] Kopadze** | Shape-Vokabular | WELCHE FORM nutzt das System? | GoF Design Patterns |
+| **[Technical] LangGraph** | Implementation | WIE wird es verdrahtet? | Framework / Runtime |
+
+## Die Drei-Säulen-Triade im Detail
+
+### 1. Steinberger = Loop-Engineering (Konzeptionell)
+
+**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.
+
+**Verwandte Wiki-Seite:** [[agent-loops.md]]
+
+### 2. LangGraph = Implementation (Infrastrukturell)
+
+**Perspektive:** Das Framework-Rückgrat.
+
+**Primitive:**
+- State (deterministischer Zustand)
+- Nodes (Aktionen)
+- Edges (Übergänge, bedingt/unbedingt)
+- Checkpointing (Durable Execution)
+- Time-Travel (Debugging)
+- Routing (Conditional Edges)
+
+**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.
+
+**Verwandte Wiki-Seite:** [[graph-based-agents.md]]
+
+### 3. Kopadze = Shape-Vokabular (Design-Patterns)
+
+**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 |
+| **Diamond** | Fan-Out + Verifier/Join | Qualitätsgesicherte parallele Verarbeitung |
+| **Hierarchical Router** | Verschachtelte Entscheidungsbäume | Komplexe Routing-Logik |
+| **Cyclic Evaluator** | Wiederholte Prüfschleifen | Qualitätsiteration, Self-Correction |
+
+**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.
+
+### Topologie
+
+```
+[Router/Splitting] ──► [Sub-Agent A: Task 1] ──┐
+                    ──► [Sub-Agent B: Task 2] ──┼─► [Evaluator/Verifier] ──► [Output/Retry]
+                    ──► [Sub-Agent C: Task 3] ──┘
+```
+
+### Warum das Diamond Pattern im Alltag dominiert
+
+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)
+- **LangGraph** liefert die Implementation (Nodes, Edges, State, Parallel Branches, Checkpointing)
+
+## Die Triade in der Praxis
+
+### Zusammenspiel
+
+```
+           ┌──────────────────────────────┐
+           │   [Kopadze] Shape-Vokabular   │
+           │   (Welche Form?)              │
+           └──────────┬───────────────────┘
+                      │ übersetzt in Topologie
+           ┌──────────▼───────────────────┐
+           │   [Steinberger]              │
+           │   Loop-Engineering            │
+           │   (Wann/Warum?)               │
+           └──────────┬───────────────────┘
+                      │ dockt an Verifier-Nodes an
+           ┌──────────▼───────────────────┐
+           │   [LangGraph]                │
+           │   Implementation             │
+           │   (Wie verdrahten?)           │
+           └──────────────────────────────┘
+```
+
+### Fazit
+
+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.
+
+## Verwandte Wiki-Seiten
+
+- [[agent-loops.md]] — Loop-Engineering (Steinberger)
+- [[graph-based-agents.md]] — Graph-basierte Agenten (LangGraph)
+- [[ai-agents-2026.md]] — AI Agents 2026 Übersicht
+- [[../../architecture/agent-orchestration.md]] — Agenten-Orchestrierung
+- [[../../architecture/model-routing.md]] — Model Routing (komplementär: Task-Spezialisierung auf Sub-Agent-Ebene)
+
+## Quellen
+
+- Rüdiger (OME Topic 13, 2026-07-26): Drei-Säulen-Triade der Agenten-Architektur
+- @steipete: Loops vs. Graphs — 248K Views, 402 Quotes (raw: `xpost/2026-07-18_steipete-loops-vs-graphs.md`)
+- LangGraph Overview: https://docs.langchain.com/oss/python/langgraph/overview
+- Harrison Chase (@hwchase17): https://x.com/hwchase17/status/1915845925316268471

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 — Rüdiger's Drei-Säulen-Triade der Agenten-Architektur: Steinberger, Kopadze, LangGraph + Diamond-Pattern. Raw: `raw/xpost/2026-07-26_ruediger-agent-architecture-triade.md`. Wiki-Updates: `concepts/agents/architecture-triade.md` (new). Log: 2026-07-26 ingest: ruediger-agent-architecture-triade.)*
 
 ## 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 |
+| [Architecture Triade: Steinberger, Kopadze, LangGraph](concepts/agents/architecture-triade.md) | Die drei Säulen der Agenten-Architektur: Loop-Engineering (Steinberger, konzeptionell), Shape-Vokabular (Kopadze, Design-Patterns), LangGraph (Implementation). Diamond-Pattern als mächtigstes Workhorse — Fan-Out + Verifier/Join löst monolithische Prompt-Dilemmata | xpost/2026-07-26_ruediger-agent-architecture-triade.md + xpost/2026-07-18_steipete-loops-vs-graphs.md |
 
 ### Policy
 | Seite | Beschreibung | Quellen |
@@ -315,3 +316,4 @@
 | `raw/xpost/2026-07-19-bridgemindai-moonshot-capacity.md` | xpost | @bridgemindai: Moonshot stoppte neue Kimi K3 Subscriptions statt bestehende Nutzer zu drosseln — Customer-first vs. Anthropic's Growth-first. 205K Views, 4.7K Likes. Go-to-market philosophy als competitive differentiator |
 | `raw/xpost/2026-07-20-healthranger-four-chinese-models.md` | xpost | @HealthRanger: "FOURTH China-based AI bombshell in four days" — Kimi (Moonshot), Qwen (Alibaba), DeepSeek, GLM (Z.ai). GLM-5.5: >1T params, open weights, August launch. Unprecedented Chinese AI cadence. 931 likes, 152 reposts, 41K+ views |
 | `raw/youtube/2026-07-23-anthropic-red-team-logan-graham.md` | youtube | Fox Business Interview mit Logan Graham (Anthropic Frontier Red Team Lead): KI-Sicherheitsrisiken, Red-Teaming-Ansatz, "weird behavior", autonome Agenten, Cybersicherheit, China/IP-Diebstahl, Chip-Exportkontrollen, Governance-Standards |
+| `architecture/sqlite-pages-7.2.md` | SQLite-Refactor & Pages-Konzept — OpenClaw 7.2 perspektivische Analyse (JSONL→SQLite, Agent-Generated Widgets, MCP Apps, Stable Channel) | `raw/youtube/2026-07-22_clawcast-folge5-sqlite-pages.md` |

wiki/log.md

@@ -2,7 +2,17 @@
 
 *Append-only changelog. Start: 2026-06-05*
 
-## [2026-07-20] Ingest | @HealthRanger Fourth Chinese AI Bombshell — GLM-5.5 Announced
+## [2026-07-26] Ingest | Rüdiger — Architecture Triade: Steinberger, Kopadze, LangGraph
+
+**Type:** ingest | **Scope:** raw/xpost, wiki/concepts/agents (1 new), wiki/index, wiki/log
+**Source:** Rüdiger (OME-Gruppe Topic 13, 2026-07-26) — Analyse der Drei-Säulen-Triade der Agenten-Architektur: Steinberger (Loop-Engineering, konzeptionell), Kopadze (Shape-Vokabular, Design-Patterns), LangGraph (Implementation). Diamond-Pattern (Fan-Out + Verifier/Join) als mächtigstes Workhorse.
+**Trigger:** Subagent task: Wikify Rüdiger's analysis as new concept page.
+**Actions:**
+- raw: `raw/xpost/2026-07-26_ruediger-agent-architecture-triade.md` (created — 5.2 KB; Frontmatter [type: analysis/synthesis, author: Rüdiger, source_group: OME-Gruppe Topic 13, tags: agent-architecture, steinberger, kopadze, langgraph, diamond-pattern, loop-engineering, shape-vocabulary, design-patterns, agent-topology, people: peter-steinberger, harrison-chase, institutions: langchain]. Content: Vollständige Analyse der Drei-Säulen-Triade mit Diamond-Pattern-Topologie und Fazit)
+- wiki (NEW): `concepts/agents/architecture-triade.md` (created — 7.8 KB; Frontmatter [sources, tags, people: peter-steinberger, harrison-chase, institutions: langchain]. Sections: Überblick (Drei-Säulen-Tabelle), Detailbeschreibung jeder Säule mit Lücken-Analyse, Kopadze-Shapes-Tabelle, Diamond-Pattern-Topologie-Diagramm, Warum Diamond dominiert, Praktisches Zusammenspiel-Diagramm, Fazit, 6 Cross-Refs)
+- wiki: `index.md` (updated — Header auf "83. Update", neuer Agents-Eintrag für Architecture Triade)
+- log: this entry
+**Hector-Hauptthese:** Rüdiger's Analyse schließt die konzeptionelle Lücke zwischen den bestehenden Wiki-Seiten `agent-loops.md` (Steinberger) und `graph-based-agents.md` (LangGraph). Die Einführung von Kopadze als "Shape-Vokabular" — analog zu GoF Design Patterns in OOP — ist der missing Link: er übersetzt Steinbergers Loop-Engineering in konkrete Topologien, die sich in LangGraph gießen lassen. Das Diamond-Pattern (Fan-Out + Verifier/Join) wird als praktische Synthese aller drei Säulen identifiziert. Die Analyse ist relevant für die Barbell-5-Tier-Routing-Strategie: Sub-Tasks im Diamond-Pattern können auf günstigere Modelle geroutet werden.\n**Subagent-Modell:** openrouter/deepseek/deepseek-v4-flash\n\n## [2026-07-20] Ingest | @HealthRanger Fourth Chinese AI Bombshell — GLM-5.5 Announced"}]
 
 **Type:** ingest | **Scope:** raw/xpost, wiki/concepts/llm (1 new + 1 updated), wiki/concepts (1 new synthesis), wiki/institutions (1 updated), wiki/index, wiki/log
 **Source:** X-Post von @HealthRanger — https://x.com/HealthRanger/status/2079250250317861292 (20.07.2026, 931 likes, 152 reposts, 43 replies, 41K+ views)