Initial public upload from Projekte/Agent8Agent

.codex/config.toml

@@ -0,0 +1,31 @@
+# Coding MCPs: project-local registration (2026-09-07).
+
+[mcp_servers.serena]
+command = "/home/smlflg/.local/share/coding-mcp/serena/.venv/bin/serena"
+args = ["start-mcp-server", "--context=codex", "--project", "/home/smlflg/Projekte/Agent8Agent", "--enable-web-dashboard", "false", "--open-web-dashboard", "false", "--enable-gui-log-window", "false"]
+cwd = "/home/smlflg/Projekte/Agent8Agent"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180
+
+[mcp_servers.serena.env]
+"SERENA_HOME" = "/home/smlflg/.local/share/coding-mcp/serena/state"
+
+[mcp_servers.gitnexus]
+command = "/home/smlflg/.nvm/versions/node/v24.13.0/bin/node"
+args = ["/home/smlflg/.local/share/coding-mcp/gitnexus/node_modules/gitnexus/dist/cli/index.js", "mcp"]
+cwd = "/home/smlflg/Projekte/Agent8Agent"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180
+
+[mcp_servers.gitnexus.env]
+"GITNEXUS_HOME" = "/home/smlflg/.local/share/coding-mcp/gitnexus/runtime"
+
+[mcp_servers.context7]
+command = "/home/smlflg/.nvm/versions/node/v24.13.0/bin/node"
+args = ["/home/smlflg/.local/share/coding-mcp/context7/node_modules/@upstash/context7-mcp/dist/index.js"]
+cwd = "/home/smlflg/Projekte/Agent8Agent"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+artifacts/hai_langgraph_multivoice_podcast_20260608/HAI_LANGGRAPH_MULTIVOICE_PODCAST.mp3 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

.python-version

@@ -0,0 +1 @@
+3.13

agent8agent/__init__.py

@@ -0,0 +1 @@
+"""Agent8Agent — die agentische Sanduhr als LangGraph (Mockup)."""

agent8agent/config.py

@@ -0,0 +1,37 @@
+"""Konfiguration für echte Substrat-Bindings."""
+
+from __future__ import annotations
+
+import sys
+
+# intake-router-hermes MCP (read-only Register-Suche).
+# Wir starten den Server mit unserem venv-Python (sys.executable), das `mcp` hat;
+# der Server selbst hat keine weiteren Deps (parst YAML manuell).
+INTAKE_MCP_COMMAND = sys.executable
+INTAKE_MCP_ARGS = [
+    "/home/smlflg/.hermes/profiles/intake-router-hermes/mcp/intake_router_fastmcp.py"
+]
+
+# action_type (Register-Vokabular) → (Route-Buchstabe, Ziel-Node)
+ACTION_TO_ROUTE = {
+    "aufgabe": ("A", "execute_with_codex"),     # klare Umsetzung → Executor
+    "idee": ("B", "research_with_opus"),         # "was gibt's schon" → Research
+    "entscheidung": ("B", "research_with_opus"), # Evidence sammeln, Owner entscheidet an der Taille
+    "reflexion": ("D", "meta_agent"),            # Rückschau/Optimierung → Meta
+    "meeting": ("E", "park"),                     # nicht agenten-actionable
+    "sonstiges": ("E", "park"),
+}
+DEFAULT_ROUTE = ("B", "research_with_opus")       # unbekannt → erst mal erkunden
+
+# urgency → priority-Tier (für späteres echtes priority_gate; Carry hier schon mit)
+URGENCY_TO_PRIORITY = {"hoch": "P0", "mittel": "P2", "niedrig": "P3"}
+
+# Keyword-Fallback, wenn das Register keinen Treffer liefert (freier Text / Studio-Demo).
+KEYWORD_FALLBACK = {
+    "execute": "aufgabe", "aufgabe": "aufgabe", "task": "aufgabe",
+    "research": "idee", "idee": "idee", "idea": "idee",
+    "reflex": "reflexion", "meta": "reflexion", "optimier": "reflexion",
+    "entscheid": "entscheidung", "decide": "entscheidung", "decision": "entscheidung",
+    "meeting": "meeting", "park": "sonstiges",
+}
+KEYWORD_FALLBACK_DEFAULT = "idee"

agent8agent/graph.py

@@ -0,0 +1,94 @@
+"""Graph-Aufbau der agentischen Sanduhr (Mockup).
+
+build_graph(checkpointer=None):
+  - checkpointer=None  → für `langgraph dev` (Studio injiziert eigene Persistenz)
+  - checkpointer=...   → für direkten Invoke/Tests (interrupt braucht einen Saver)
+"""
+
+from __future__ import annotations
+
+from langgraph.graph import END, START, StateGraph
+
+from .nodes import (
+    automation_output,
+    execute_with_codex,
+    fan_out_research,
+    hai_owner_packet,
+    human_escalation,
+    intake_router,
+    learning_agent,
+    meta_agent,
+    park,
+    priority_gate,
+    research_subagent,
+    research_with_opus,
+    route_after_verifier,
+    route_thought,
+    verifier_mediator,
+)
+from .state import ThoughtState
+
+
+def build_graph(checkpointer=None):
+    g = StateGraph(ThoughtState)
+
+    # Nodes
+    g.add_node("intake_router", intake_router)
+    g.add_node("priority_gate", priority_gate)
+    g.add_node("execute_with_codex", execute_with_codex)
+    g.add_node("research_with_opus", research_with_opus)
+    g.add_node("research_subagent", research_subagent)
+    g.add_node("learning_agent", learning_agent)
+    g.add_node("meta_agent", meta_agent)
+    g.add_node("park", park)
+    g.add_node("verifier_mediator", verifier_mediator)
+    g.add_node("human_escalation", human_escalation)
+    g.add_node("hai_owner_packet", hai_owner_packet)
+    g.add_node("automation_output", automation_output)
+
+    # Intake-Pyramide
+    g.add_edge(START, "intake_router")
+    g.add_edge("intake_router", "priority_gate")
+
+    # prio-Gate → Lane (A/B/C/D/E)
+    g.add_conditional_edges(
+        "priority_gate",
+        route_thought,
+        {
+            "execute_with_codex": "execute_with_codex",
+            "research_with_opus": "research_with_opus",
+            "learning_agent": "learning_agent",
+            "meta_agent": "meta_agent",
+            "park": "park",
+        },
+    )
+
+    # Research-Lane: Send-Fanout → Subagenten → join
+    g.add_conditional_edges("research_with_opus", fan_out_research, ["research_subagent"])
+    g.add_edge("research_subagent", "verifier_mediator")
+
+    # Übrige Lanes → Verifier
+    g.add_edge("execute_with_codex", "verifier_mediator")
+    g.add_edge("learning_agent", "verifier_mediator")
+    g.add_edge("meta_agent", "verifier_mediator")
+
+    # park ist terminal (Anti-Fanout-Ventil)
+    g.add_edge("park", END)
+
+    # Konflikt-Lane
+    g.add_conditional_edges(
+        "verifier_mediator",
+        route_after_verifier,
+        {"human_escalation": "human_escalation", "hai_owner_packet": "hai_owner_packet"},
+    )
+    g.add_edge("human_escalation", "hai_owner_packet")
+
+    # Taille → Automation-Output → Ende
+    g.add_edge("hai_owner_packet", "automation_output")
+    g.add_edge("automation_output", END)
+
+    return g.compile(checkpointer=checkpointer)
+
+
+# Modul-Level-Graph für LangGraph Studio (langgraph.json).
+graph = build_graph()

agent8agent/mcp_client.py

@@ -0,0 +1,45 @@
+"""Minimaler stdio-Client für den intake-router-hermes MCP-Server.
+
+LangGraph läuft als eigener Prozess; wir starten den read-only MCP-Server per
+stdio, rufen ein Tool, parsen die JSON-Antwort. Synchron nutzbar via run_sync()
+(eigener Thread + eigener Event-Loop → funktioniert auch unter Studio/asyncio).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+import json
+from typing import Any
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from .config import INTAKE_MCP_ARGS, INTAKE_MCP_COMMAND
+
+
+async def call_intake_tool(name: str, arguments: dict | None = None) -> dict[str, Any]:
+    """Einen Tool-Call gegen den intake-router MCP fahren und JSON zurückgeben."""
+    params = StdioServerParameters(
+        command=INTAKE_MCP_COMMAND, args=INTAKE_MCP_ARGS, env=None
+    )
+    async with stdio_client(params) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+            result = await session.call_tool(name, arguments or {})
+    # Server liefert genau ein TextContent mit JSON-String.
+    for block in result.content:
+        text = getattr(block, "text", None)
+        if text:
+            return json.loads(text)
+    return {}
+
+
+def run_sync(coro):
+    """Coroutine in einem frischen Thread+Loop ausführen (kollisionsfrei)."""
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as ex:
+        return ex.submit(lambda: asyncio.run(coro)).result()
+
+
+def call_intake_tool_sync(name: str, arguments: dict | None = None) -> dict[str, Any]:
+    return run_sync(call_intake_tool(name, arguments))

agent8agent/nodes.py

@@ -0,0 +1,241 @@
+"""Nodes der Sanduhr.
+
+Status: `intake_router` ist SCHARF (echter intake-router-hermes MCP). Alle anderen
+Nodes sind weiterhin Mock — Interrupt und Send-Fanout sind echte LangGraph-Mechanik.
+"""
+
+from __future__ import annotations
+
+import re
+
+from langgraph.types import Send, interrupt
+
+from . import config
+from .mcp_client import call_intake_tool_sync
+
+N_RESEARCH_SUBAGENTS = 3
+_IR_RE = re.compile(r"\bIR-\d{4}-\d{4}\b", re.IGNORECASE)
+
+
+# --- Helpers ---------------------------------------------------------------
+
+def _keyword_action(raw: str) -> str:
+    low = raw.lower()
+    for kw, action in config.KEYWORD_FALLBACK.items():
+        if kw in low:
+            return action
+    return config.KEYWORD_FALLBACK_DEFAULT
+
+
+def _as_list(value) -> list[str]:
+    if not value:
+        return []
+    if isinstance(value, str):
+        return [value] if value.strip() else []
+    return [str(x) for x in value if x and str(x).strip()]
+
+
+def _fetch_intake(raw: str) -> tuple[dict | None, list[dict], str]:
+    """Register abfragen. Returns (top_intake | None, sources, note).
+
+    Resilient: fällt bei MCP-Fehler auf (None, [], 'mcp-unavailable') zurück,
+    damit der Graph nie deadlockt, wenn hermes down ist.
+    """
+    try:
+        m = _IR_RE.search(raw)
+        if m:
+            resp = call_intake_tool_sync("get_intake_details", {"intake_id": m.group(0).upper()})
+            if resp.get("success"):
+                return resp.get("intake"), [], f"register-id {m.group(0).upper()}"
+            return None, [], f"id {m.group(0).upper()} nicht gefunden"
+        resp = call_intake_tool_sync("query_intakes", {"query": raw, "limit": 5})
+        matches = resp.get("matches", [])
+        if matches:
+            return matches[0], matches, f"register-match {matches[0].get('id')}"
+        return None, [], "kein register-treffer"
+    except Exception as exc:  # hermes nicht erreichbar
+        return None, [], f"mcp-unavailable: {type(exc).__name__}"
+
+
+# --- Intake-Pyramide -------------------------------------------------------
+
+def intake_router(state: dict) -> dict:
+    """SCHARF: echter intake-router-hermes MCP (read-only Register-Suche).
+
+    raw_input == IR-id → get_intake_details, sonst query_intakes. Top-Treffer →
+    classification (action_type), active_project, evidence. Ohne Treffer:
+    Keyword-Fallback, damit freier Text / Studio-Demo trotzdem routet.
+    """
+    raw = state.get("raw_input", "")
+    intake, sources, note = _fetch_intake(raw)
+
+    if intake:
+        action = (intake.get("action_type") or "").strip().lower() or _keyword_action(raw)
+        summary = intake.get("summary") or intake.get("title") or raw[:80]
+        projects = _as_list(intake.get("projects"))
+        topics = _as_list(intake.get("topics"))
+        urgency = (intake.get("urgency") or "").strip().lower()
+        evidence = [{
+            "agent": "intake-router-hermes", "kind": "intake-match",
+            "id": intake.get("id"), "title": intake.get("title"),
+            "action_type": action, "urgency": urgency,
+        }]
+        intake_id = intake.get("id")
+        status = intake.get("status", "")
+        confidence = intake.get("confidence", "")
+    else:
+        action = _keyword_action(raw)
+        summary = f"[{note}] {raw[:80]}"
+        projects, topics, urgency, evidence = [], [], "", []
+        intake_id = status = confidence = None
+
+    return {
+        "classification": action,
+        "summary": summary,
+        "active_project": projects[0] if projects else None,
+        "topics": topics,
+        "selected_agents": ["intake-router-hermes"],
+        "current_gate": "intake_router",
+        "evidence": evidence,
+        "intake": {
+            "id": intake_id, "urgency": urgency, "status": status,
+            "confidence": confidence, "note": note, "sources": sources,
+        },
+    }
+
+
+def priority_gate(state: dict) -> dict:
+    """Mappt classification → Route und urgency → priority. park = Anti-Fanout-Ventil."""
+    classification = state.get("classification", "idee")
+    urgency = (state.get("intake") or {}).get("urgency", "")
+    route, _ = config.ACTION_TO_ROUTE.get(classification, config.DEFAULT_ROUTE)
+    priority = "park" if route == "E" else config.URGENCY_TO_PRIORITY.get(urgency, "P2")
+    return {
+        "priority": priority,
+        "route": route,
+        "owner_decision_needed": route != "E",
+        "current_gate": "priority_gate",
+    }
+
+
+def route_thought(state: dict) -> str:
+    """Conditional-Edge-Fn: prio-Gate → Lane."""
+    if state.get("priority") == "park":
+        return "park"
+    classification = state.get("classification", "idee")
+    _, target = config.ACTION_TO_ROUTE.get(classification, config.DEFAULT_ROUTE)
+    return target
+
+
+# --- Executor-Pyramide (Lanes, weiterhin Mock) -----------------------------
+
+def execute_with_codex(state: dict) -> dict:
+    return {
+        "selected_agents": ["codex"],
+        "execution_status": "[mock] codex hätte ausgeführt",
+        "evidence": [{"agent": "codex", "kind": "execution", "note": "mock diff/patch"}],
+        "current_gate": "execute_with_codex",
+    }
+
+
+def research_with_opus(state: dict) -> dict:
+    return {
+        "selected_agents": ["opus-research"],
+        "execution_status": "[mock] opus startet Prior-Art-Schwarm",
+        "current_gate": "research_with_opus",
+    }
+
+
+def fan_out_research(state: dict) -> list[Send]:
+    raw = state.get("raw_input", "")
+    return [
+        Send("research_subagent", {"raw_input": raw, "_idx": i})
+        for i in range(N_RESEARCH_SUBAGENTS)
+    ]
+
+
+def research_subagent(state: dict) -> dict:
+    idx = state.get("_idx", 0)
+    return {
+        "evidence": [
+            {"agent": f"opus-subagent-{idx}", "kind": "prior-art",
+             "note": f"[mock] Fund #{idx}: 'gibt's schon' …"}
+        ],
+    }
+
+
+def learning_agent(state: dict) -> dict:
+    return {
+        "selected_agents": ["learning-agent"],
+        "execution_status": "[mock] learnmode hätte Lernlücke geschlossen",
+        "evidence": [{"agent": "learning-agent", "kind": "explanation", "note": "mock"}],
+        "current_gate": "learning_agent",
+    }
+
+
+def meta_agent(state: dict) -> dict:
+    return {
+        "selected_agents": ["meta-agent"],
+        "execution_status": "[mock] metamode hätte Workflow optimiert",
+        "evidence": [{"agent": "meta-agent", "kind": "optimization", "note": "mock"}],
+        "current_gate": "meta_agent",
+    }
+
+
+def park(state: dict) -> dict:
+    return {
+        "execution_status": "[mock] geparkt — low prio / nicht actionable",
+        "current_gate": "park",
+        "owner_decision_needed": False,
+    }
+
+
+# --- Konflikt-Lane (Mock) --------------------------------------------------
+
+def verifier_mediator(state: dict) -> dict:
+    raw = state.get("raw_input", "").lower()
+    status = "conflict" if "conflict" in raw else "ok"
+    return {"verifier_status": status, "current_gate": "verifier_mediator"}
+
+
+def route_after_verifier(state: dict) -> str:
+    return "human_escalation" if state.get("verifier_status") == "conflict" else "hai_owner_packet"
+
+
+def human_escalation(state: dict) -> dict:
+    return {
+        "execution_status": "[mock] Konflikt → an Human eskaliert",
+        "current_gate": "human_escalation",
+    }
+
+
+# --- Taille (HAI Owner Packet, echtes interrupt) ---------------------------
+
+def hai_owner_packet(state: dict) -> dict:
+    packet = {
+        "decisions": [
+            {"id": "approve", "label": "Freigeben & ausführen"},
+            {"id": "revise", "label": "Überarbeiten"},
+            {"id": "drop", "label": "Verwerfen"},
+        ],
+        "evidence": state.get("evidence", []),
+        "next_action": "[mock] nächster Schritt laut Lane",
+        "summary": state.get("summary", ""),
+    }
+    decision = interrupt(packet)
+    return {
+        "owner_packet": packet,
+        "owner_decision_needed": False,
+        "execution_status": f"[mock] owner entschied: {decision}",
+        "current_gate": "hai_owner_packet",
+    }
+
+
+# --- Automation-Output (n8n-Sink, Mock) ------------------------------------
+
+def automation_output(state: dict) -> dict:
+    sinks = ["mail", "notion", "obsidian", "github", "calendar"]
+    return {
+        "execution_status": f"[mock] würde an n8n posten → {', '.join(sinks)}",
+        "current_gate": "automation_output",
+    }

agent8agent/state.py

@@ -0,0 +1,30 @@
+"""ThoughtState — der State, der durch die Sanduhr fließt.
+
+Feldnamen verbatim nach Samuels Spec, plus ein paar Carry-Felder für den Mockup-Lauf.
+"""
+
+from __future__ import annotations
+
+import operator
+from typing import Annotated, TypedDict
+
+
+class ThoughtState(TypedDict, total=False):
+    # --- Samuels Spec (verbatim) ---
+    raw_input: str
+    classification: str          # task | research | learning | meta | noise
+    priority: str                # P0..P3 | park
+    active_project: str | None
+    selected_agents: list[str]   # gewählte Lane(s)
+    current_gate: str            # wo im Graph wir gerade stehen
+    evidence: Annotated[list[dict], operator.add]  # reducer → merge'd Fanout-Beiträge
+    owner_decision_needed: bool
+    execution_status: str
+    verifier_status: str
+
+    # --- Carry ---
+    summary: str
+    topics: list[str]            # aus dem Register (best effort)
+    intake: dict                 # roh: id/urgency/status/confidence/note/sources
+    route: str                   # A | B | C | D | E
+    owner_packet: dict

artifacts/hai_langgraph_multivoice_podcast_20260608/HAI_LANGGRAPH_MULTIVOICE_PODCAST.md

@@ -0,0 +1,158 @@
+# Multivoice-Erklärpodcast: LangGraph für Samuels HAI-Sanduhr
+
+Quelle: Samuels Task-Package im Chat vom 2026-06-08.
+Modus: EXPLAIN mit Rückaneignungs-Check, kein Full-Build.
+
+## Stimmen
+- MODERATORIN: de-DE-KatjaNeural
+- COACH: de-DE-FlorianMultilingualNeural
+- ARCHITEKTIN: de-DE-SeraphinaMultilingualNeural
+- KRITIKER: de-DE-ConradNeural
+- SAMUEL-STIMME: de-DE-KillianNeural
+- MERKSATZ: de-DE-AmalaNeural
+
+## Skript
+
+### 01. MODERATORIN
+Willkommen zum HAI-LangGraph-Podcast. Heute geht es nicht um ein großes Framework-Tutorial, sondern um einen einzigen Gedanken, der sauber durch Samuels HAI-Sanduhr läuft.
+
+### 02. COACH
+Lernziel: Am Ende kannst du sagen: Mein HAI-Loop besteht aus State X, Knoten Y, Übergängen Z und einem Human-Gate. Wenn du genau diesen Satz füllen kannst, hast du das Modell verstanden.
+
+### 03. SAMUEL-STIMME
+Also nicht: Baue komplettes HAI. Sondern: Baue einen Graphen, der einen Gedanken aufnimmt, Samuel entscheiden lässt, fokussiert ausführt, prüft und ins Register zurückbringt.
+
+### 04. ARCHITEKTIN
+LangGraph ist hier das Schienensystem. Der State ist der gemeinsame Zettel. Nodes sind Arbeitsschritte. Edges sind Gleise. Conditional Edges sind Weichen. Das Human-Gate ist die Stelle, an der Samuel Owner bleibt.
+
+### 05. MODERATORIN
+Kapitel eins: State. Die Kernfrage lautet: Was muss der Graph wissen, damit Samuel es nicht im Kopf halten muss?
+
+### 06. COACH
+Für HAI enthält der State mindestens: aktueller Gedanke oder Intake, Kategorie, ob eine Entscheidung nötig ist, gewählter nächster Schritt, aktiver Executor, Ergebnis, Verifikation und Status im Register.
+
+### 07. ARCHITEKTIN
+Denke nicht an State als Datenbank-Monster. Denke an eine Prozesskarte. Wenn der Gedanke später wieder auftaucht, soll der Graph wissen: Was war entschieden, was ist offen, und wo steht die Arbeit?
+
+### 08. KRITIKER
+Wenn etwas nur in Samuels Kopf bleibt, ist es kein robuster HAI-Prozess. Es wird wieder Chat-Nebel. State heißt: Der Graph trägt die Last, nicht Samuels Arbeitsgedächtnis.
+
+### 09. MERKSATZ
+State ist der gemeinsame Arbeitsstand. Er beantwortet: Was wissen wir gerade, was wurde entschieden, und was darf als Nächstes passieren?
+
+### 10. MODERATORIN
+Kapitel zwei: Nodes. Die Kernfrage lautet: Welche Schritte mache ich heute manuell immer wieder?
+
+### 11. COACH
+Ein Node ist ein Arbeitsschritt im Graphen. Für HAI wären das: intake_node, classify_node, owner_decision_node, task_package_node, executor_node, verifier_node, return_node und register_update_node.
+
+### 12. SAMUEL-STIMME
+Intake nimmt Chaos auf. Classify sortiert. Owner Decision fragt mich. Task Package macht Arbeit greifbar. Executor arbeitet. Verifier prüft. Return bringt das Ergebnis zurück. Register Update verhindert, dass es verschwindet.
+
+### 13. ARCHITEKTIN
+Das ist die Sanduhr: oben breit, in der Mitte eng, unten wieder strukturiert. Oben darf Chaos rein. In der Taille entscheidet Samuel. Danach darf genau eine fokussierte Ausführung passieren.
+
+### 14. KRITIKER
+Wichtig: Ein Node ist nicht automatisch ein Agent. Ein Node kann auch nur eine kleine Regel sein: Kategorie setzen, Stop-Kriterium prüfen, oder einen Status ins Register schreiben.
+
+### 15. MODERATORIN
+Kapitel drei: Edges. Die Kernfrage lautet: Welche Übergänge dürfen automatisch passieren, welche nicht?
+
+### 16. COACH
+Einfache Edges sind feste Übergänge. Intake geht immer zu Classify. Executor geht immer zu Verify. Return geht danach zum Register Update. Das sind sichere Gleise.
+
+### 17. ARCHITEKTIN
+Aber Classify darf nicht blind in Ausführung springen. Nach der Klassifikation kommt entweder Review, Owner Gate oder Stop. Genau dort wird aus Automation ein verantwortbarer Prozess.
+
+### 18. SAMUEL-STIMME
+Automatisch darf passieren, was nur sortiert oder prüft. Nicht automatisch darf passieren, was Arbeit auslöst, sensible Entscheidungen trifft oder Agenten losschickt.
+
+### 19. MERKSATZ
+Edges sind nicht nur technische Pfeile. Edges sind Erlaubnisse: Dieser Schritt darf jetzt in jenen Schritt übergehen.
+
+### 20. MODERATORIN
+Kapitel vier: Conditional Edges. Die Kernfrage lautet: Wo soll das System Samuel bremsen?
+
+### 21. COACH
+Conditional Edges sind Weichen. Sensibel? Dann nur Samuel. Confidence unter null Komma fünf? Dann Review. Samuel sagt Go? Dann Executor. Verifikation fehlgeschlagen? Dann zurück, retry oder stop.
+
+### 22. KRITIKER
+Das ist kein Misstrauen gegen Automation. Das ist gutes Systemdesign. Ein HAI-Graph ohne Bremsen wird zur Agenten-Rutschbahn. Ein HAI-Graph mit Weichen bleibt führbar.
+
+### 23. ARCHITEKTIN
+Die wichtigsten Bedingungen sind nicht kompliziert: Ist es sensibel? Ist genug Sicherheit da? Hat Samuel zugestimmt? Hat die Prüfung bestanden? Daraus entsteht der Kontrollfluss.
+
+### 24. MERKSATZ
+Conditional Edges sind die Sicherheitslogik des Graphen. Sie sagen nicht nur wohin, sondern unter welcher Bedingung.
+
+### 25. MODERATORIN
+Kapitel fünf: Human-in-the-loop. Das ist der wichtigste Teil.
+
+### 26. COACH
+Der Graph muss an der Taille stoppen und Samuel fragen: Willst du daraus Arbeit machen? Ja, nein, oder welcher Modus? Vor diesem Gate wird sortiert. Nach diesem Gate wird ausgeführt.
+
+### 27. SAMUEL-STIMME
+Das Human-Gate ist also nicht ein nettes Popup. Es ist der Ownership-Punkt. HAI darf vorbereiten, aber ich entscheide, ob daraus echte Arbeit wird.
+
+### 28. KRITIKER
+Wenn der Graph hier nicht stoppt, verliert Samuel die Autorenschaft. Dann optimiert das System vielleicht fleißig, aber nicht unbedingt in Samuels Richtung.
+
+### 29. MERKSATZ
+Human-in-the-loop heißt: Samuel bleibt Owner an der Entscheidung, nicht Zuschauer nach der Ausführung.
+
+### 30. MODERATORIN
+Kapitel sechs: Checkpointing und Persistence. Die Kernfrage lautet: Wie verhindere ich, dass Arbeit wieder in Chats verschwindet?
+
+### 31. ARCHITEKTIN
+Checkpointing heißt: Der Graph kann seinen Zustand speichern und wieder aufnehmen. Für HAI heißt das: Was war entschieden, was wurde delegiert, was ist offen, wo kam Ergebnis zurück, und was wurde im Register aktualisiert?
+
+### 32. COACH
+Ohne Persistence ist LangGraph nur ein hübscher Ablauf im Moment. Mit Persistence wird HAI zu einem Arbeitsgedächtnis: Entscheidungen, Pakete, Ergebnisse und offene Knoten bleiben auffindbar.
+
+### 33. SAMUEL-STIMME
+Das Register ist die sichtbare Rückgabe in mein System. Nicht nur: Agent hat etwas gesagt. Sondern: Status, Ergebnis, Prüfung und nächster offener Punkt sind eingetragen.
+
+### 34. MODERATORIN
+Kapitel sieben: Tool- und Agent-Calls. Die Kernfrage lautet: Wie verhindere ich unkontrollierten Agenten-Fanout?
+
+### 35. COACH
+Die Regel für HAI ist eng: Erst nach Owner-Go. Genau ein Executor. Mit Task-Package. Mit Stop-Kriterium. Danach Verifikation. Kein breiter Fanout, kein autonomes Herumwuchern.
+
+### 36. KRITIKER
+Ein Executor ohne Task-Package ist ein Risiko. Ein Task-Package ohne Stop-Kriterium ist ein offener Sumpf. Ein Ergebnis ohne Verifikation ist nur eine Behauptung.
+
+### 37. ARCHITEKTIN
+Deshalb erzeugt task_package_node nicht einfach Prompt-Text. Er begrenzt Arbeit: Ziel, Input, erlaubte Tools, Definition von fertig, Verifikationskriterium und Rückgabeformat.
+
+### 38. MERKSATZ
+Agent Calls passieren in HAI nicht, weil ein Agent könnte. Sie passieren, weil Samuel nach dem Gate genau eine begrenzte Ausführung erlaubt hat.
+
+### 39. MODERATORIN
+Kapitel acht: Minimaler Graph statt Mega-System.
+
+### 40. COACH
+Der kleinste sinnvolle Graph führt genau einen Gedanken durch die Sanduhr: Intake, Classify, Owner Gate, Task Package, Executor, Verify, Return, Register Update.
+
+### 41. SAMUEL-STIMME
+Wenn ich diesen einen Gedanken sauber durchbekomme, verstehe ich LangGraph praktisch. Wenn ich sofort HAI komplett baue, verstecke ich mein fehlendes Modell unter Architektur.
+
+### 42. KRITIKER
+Das Ziel ist nicht Größe. Das Ziel ist Kontrollierbarkeit. Ein kleiner Graph, den Samuel erklären kann, ist wertvoller als ein großes System, das niemand mehr besitzt.
+
+### 43. MODERATORIN
+Jetzt die Rückaneignung. Pausiere nach diesem Podcast und fülle den Satz selbst.
+
+### 44. COACH
+Mein HAI-Loop besteht aus State: Gedankenstatus, Kategorie, Entscheidung, nächster Schritt, Executor, Ergebnis, Verifikation und Registerstatus.
+
+### 45. ARCHITEKTIN
+Knoten: Intake, Classify, Owner Decision, Task Package, Executor, Verifier, Return und Register Update.
+
+### 46. KRITIKER
+Übergänge: sichere automatische Edges für Sortieren und Prüfen; Conditional Edges für Sensibilität, Confidence, Samuel-Go und Verifikationsfehler.
+
+### 47. MERKSATZ
+Human-Gate: An der Taille bleibt Samuel Owner und entscheidet, ob aus einem Gedanken Arbeit wird.
+
+### 48. COACH
+Dein Check: Erkläre jetzt in deinen eigenen Worten einen einzigen HAI-Durchlauf. Nicht perfekt. Nur: State, Nodes, Edges, Conditional Edges und Human-Gate. Wenn du das kannst, ist das mentale Modell da.

artifacts/hai_langgraph_multivoice_podcast_20260608/HAI_LANGGRAPH_MULTIVOICE_PODCAST.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca2dfcee04c7e205261dbb0b505d6b0acba35bc44c80b50daaf63e9f90a87a22
+size 2440173

artifacts/hai_langgraph_multivoice_podcast_20260608/ffmpeg_concat.txt

@@ -0,0 +1,48 @@
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/001_moderatorin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/002_coach.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/003_samuel_stimme.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/004_architektin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/005_moderatorin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/006_coach.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/007_architektin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/008_kritiker.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/009_merksatz.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/010_moderatorin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/011_coach.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/012_samuel_stimme.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/013_architektin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/014_kritiker.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/015_moderatorin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/016_coach.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/017_architektin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/018_samuel_stimme.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/019_merksatz.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/020_moderatorin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/021_coach.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/022_kritiker.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/023_architektin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/024_merksatz.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/025_moderatorin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/026_coach.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/027_samuel_stimme.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/028_kritiker.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/029_merksatz.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/030_moderatorin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/031_architektin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/032_coach.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/033_samuel_stimme.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/034_moderatorin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/035_coach.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/036_kritiker.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/037_architektin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/038_merksatz.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/039_moderatorin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/040_coach.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/041_samuel_stimme.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/042_kritiker.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/043_moderatorin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/044_coach.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/045_architektin.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/046_kritiker.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/047_merksatz.mp3'
+file '/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/segments/048_coach.mp3'

artifacts/hai_langgraph_multivoice_podcast_20260608/manifest.json

@@ -0,0 +1,21 @@
+{
+  "mode": "EXPLAIN",
+  "summary_mode": false,
+  "source": "user-provided HAI LangGraph task package in current chat",
+  "segment_count": 48,
+  "voices_used": [
+    "de-DE-AmalaNeural",
+    "de-DE-ConradNeural",
+    "de-DE-FlorianMultilingualNeural",
+    "de-DE-KatjaNeural",
+    "de-DE-KillianNeural",
+    "de-DE-SeraphinaMultilingualNeural"
+  ],
+  "markdown_path": "/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/HAI_LANGGRAPH_MULTIVOICE_PODCAST.md",
+  "audio_path": "/home/smlflg/Projekte/Agent8Agent/artifacts/hai_langgraph_multivoice_podcast_20260608/HAI_LANGGRAPH_MULTIVOICE_PODCAST.mp3",
+  "duration_seconds": 406.656,
+  "max_segment_chars": 225,
+  "playback_returncode": 0,
+  "played_detected": true,
+  "elapsed_seconds": 524.33
+}