┌─────────────────────────────────────────────────────────────────────────────────┐
│         Das KI-Autonomiespektrum: Vom vollständigen Menschen zum vollständigen Agent│
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  MENSCH-DOMINIERT                          VOLLSTÄNDIG AUTONOM                  │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐            │
│  │                 │    │                 │    │                 │            │
│  │   KI als Werkzeug│───▶│  Human-in-Loop │───▶│ KI als Agent    │            │
│  │                 │    │                 │    │                 │            │
│  └─────────────────┘    └─────────────────┘    └─────────────────┘            │
│       2020-2023            2024-2026+           2027+ (Selektiv)                │
│                                                                                 │
│  • Mensch startet        • KI schlägt vor,     • KI führt aus                   │
│  • KI assistiert         • Mensch genehmigt     • Mensch überwacht               │
│  • Mensch entscheidet   • Kollaborativ         • Ausnahmebehandlung            │
│                                                                                 │
│  Aktueller Stand:        Entstehendes Muster:   Zielzustand:                     │
│  ChatGPT, Copilot        n8n + KI + HITL        Überwachte Autonomie            │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│                   Vergleich der menschlichen Beteiligungsmuster                  │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   HOOTL              HOTL                    HITL                               │
│   (Kein Mensch)      (Überwachend)        (Kollaborativ)                      │
│                                                                                 │
│   ┌─────────┐        ┌─────────┐             ┌─────────┐                         │
│   │   KI    │        │   KI    │             │   KI    │                         │
│   │  Agent  │        │  Agent  │             │  Agent  │                         │
│   └────┬────┘        └────┬────┘             └────┬────┘                         │
│        │                  │                        │                               │
│        │                  │    ┌─────────┐         │    ┌─────────┐                │
│        │                  ├───▶│ Mensch  │         ├───▶│ Mensch  │                │
│        │                  │    │ Monitor │◄────────│    │ Prüfung │                │
│        │                  │    └─────────┘         │    └────┬────┘                │
│        │                  │         │              │       │                      │
│        ▼                  ▼         ▼              ▼       ▼                      │
│   ┌─────────┐        ┌─────────┐             ┌─────────┐                         │
│   │ Ausführen│        │ Ausführen│             │ Ausführen│                         │
│   │ (Auto)  │        │ (Auto)  │             │ (Nach    │                         │
│   └─────────┘        └─────────┘             │Genehmig.)│                         │
│                                                └─────────┘                         │
│                                                                                 │
│   Risiko: HOCH       Risiko: MITTEL          Risiko: NIEDRIG                    │
│   Geschwindigkeit: MAX Geschwindigkeit: HOCH Geschwindigkeit: MODERAT           │
│   Vertrauen: NIEDRIG Vertrauen: MITTEL      Vertrauen: HOCH                   │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

// Workflow: KI-Inhalts-Genehmigungs-Pipeline
// Nodes: Webhook → KI-Agent → Genehmigungsanfrage → Bedingung → Ausführen/Veröffentlichen

// Node 1: Webhook-Trigger (empfängt Inhaltsanfrage)
{
  "name": "Inhaltsanfrage",
  "type": "n8n-nodes-base.webhook",
  "webhookUri": "https://your-n8n.com/webhook/content-approval",
  "responseMode": "responseNode"
}

// Node 2: KI-Inhaltsgenerierung (OpenAI/Claude)
{
  "name": "Inhalt generieren",
  "type": "@n8n/n8n-nodes-langchain.agent",
  "options": {
    "options": {
      "systemMessage": "Du bist ein professioneller Content-Autor...",
      "temperature": 0.7
    }
  },
  "prompt": "={{ $json.query }}"
}

// Node 3: Ausstehende Genehmigung speichern (Datenbank)
{
  "name": "Genehmigungsdatensatz erstellen",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "content_approvals",
  "columns": {
    "content_id": "={{ $json.id }}",
    "content": "={{ $json.generated_content }}",
    "status": "ausstehend",
    "requested_by": "={{ $json.user }}",
    "created_at": "={{ $now }}"
  }
}

// Node 4: Genehmigungsanfrage senden (Slack/E-Mail)
{
  "name": "Genehmigung anfordern",
  "type": "n8n-nodes-base.slack",
  "operation": "post",
  "channel": "content-approvers",
  "text": "📝 Neue Inhalte erfordern Genehmigung",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Inhalte zur Überprüfung bereit*\n{{ $json.content_preview }}"
      }
    },
    {
      "type": "actions",
      "elements": [
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "✅ Genehmigen" },
          "action_id": "approve_content",
          "value": "{{ $json.content_id }}"
        },
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "❌ Ablehnen" },
          "action_id": "reject_content",
          "value": "{{ $json.content_id }}"
        },
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "✏️ Bearbeiten" },
          "action_id": "edit_content",
          "url": "https://cms.example.com/edit/{{ $json.content_id }}"
        }
      ]
    }
  ]
}

// Node 5: Auf Genehmigungsantwort warten
{
  "name": "Auf Genehmigung warten",
  "type": "n8n-nodes-base.wait",
  "waitType": "webhook",
  "webhookSuffix": "approval-response",
  "continue": "receiveWebhook"
}

// Node 6: Genehmigungsentscheidung verarbeiten
{
  "name": "Genehmigungsentscheidung",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "string": [
      { "value1": "={{ $json.action }}", "value2": "approved" }
    ]
  }
}

// Zweig: Genehmigt → Veröffentlichen
{
  "name": "Inhalt veröffentlichen",
  "type": "n8n-nodes-base.httpRequest",
  "method": "POST",
  "url": "https://cms.example.com/api/publish",
  "body": {
    "content_id": "={{ $json.content_id }}",
    "approved_by": "={{ $json.approver }}",
    "approved_at": "={{ $now }}"
  }
}

// Zweig: Abgelehnt → Benachrichtigen & Protokollieren
{
  "name": "Ablehnungs-Handler",
  "type": "n8n-nodes-base.slack",
  "operation": "post",
  "channel": "content-requests",
  "text": "❌ Inhalt abgelehnt von {{ $json.approver }}: {{ $json.rejection_reason }}"
}

// Workflow: Intelligentes Ausnahme-Routing

// Node 1: Eingabe empfangen (von KI-System oder externer Quelle)
{
  "name": "Eingabeverarbeitung",
  "type": "n8n-nodes-base.webhook"
}

// Node 2: Konfidenzbewertung und Risikobewertung
{
  "name": "Konfidenz berechnen",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    // Berechnung des zusammengesetzten Konfidenzwerts
    const aiConfidence = $json.ai_confidence || 0;
    const patternMatch = $json.similarity_score || 0;
    const historicalAccuracy = $json.model_accuracy || 0.85;
    
    // Gewichtete Konfidenzberechnung
    const confidenceScore = (
      aiConfidence * 0.5 +
      patternMatch * 0.3 +
      historicalAccuracy * 0.2
    );
    
    // Risikobewertung
    const riskFactors = [];
    if ($json.amount > 10000) riskFactors.push('hoher_wert');
    if ($json.customer_tier === 'enterprise') riskFactors.push('vip_kunde');
    if ($json.is_novel_situation) riskFactors.push('neuartiger_fall');
    
    return [{
      json: {
        ...$json,
        confidence_score: confidenceScore,
        risk_factors: riskFactors,
        risk_level: riskFactors.length > 1 ? 'hoch' : riskFactors.length > 0 ? 'mittel' : 'niedrig',
        requires_human_review: confidenceScore < 0.8 || riskFactors.length > 0
      }
    }];
  `
}

// Node 3: Routing-Entscheidung
{
  "name": "Routing-Entscheidung",
  "type": "n8n-nodes-base.switch",
  "rules": {
    "rules": [
      {
        "value": "={{ $json.requires_human_review }}",
        "output": 0  // An Mensch weiterleiten
      },
      {
        "value": "={{ true }}",
        "output": 1  // Auto-verarbeiten
      }
    ]
  }
}

// Route 0: Menschliche Review-Warteschlange
{
  "name": "Ticket erstellen",
  "type": "n8n-nodes-base.jira",
  "operation": "create",
  "project": "AIEX",
  "issueType": "Ausnahme",
  "summary": "KI-Ausnahme: {{ $json.case_type }} - Konfidenz {{ $json.confidence_score }}",
  "description": `
    *KI-Verarbeitungsergebnisse:*
    - Konfidenzwert: {{ $json.confidence_score }}
    - Risikofaktoren: {{ $json.risk_factors.join(', ') }}
    - KI-Empfehlung: {{ $json.ai_recommendation }}
    
    *Kontext:*
    {{ JSON.stringify($json.context, null, 2) }}
    
    [Im KI-Dashboard ansehen](https://ai.example.com/cases/{{ $json.case_id }})
  `,
  "priority": "={{ $json.risk_level === 'hoch' ? 'Hoch' : 'Mittel' }}"
}

// Route 1: Auto-verarbeiten
{
  "name": "Auto-ausführen",
  "type": "n8n-nodes-base.httpRequest",
  "url": "https://api.example.com/execute",
  "method": "POST",
  "body": "={{ $json }}"
}

// Node 4: Warteschlangenverwaltung und Lastenausgleich
{
  "name": "Spezialisten zuweisen",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    WITH available_experts AS (
      SELECT expert_id, current_load, specialization
      FROM expert_queue
      WHERE status = 'available'
      AND specialization && $1
      ORDER BY current_load ASC
      LIMIT 1
    )
    UPDATE expert_queue
    SET current_load = current_load + 1,
        assigned_case = $2
    WHERE expert_id = (SELECT expert_id FROM available_experts)
    RETURNING expert_id
  `,
  "parameters": [
    "={{ $json.risk_factors }}",
    "={{ $json.case_id }}"
  ]
}

// Node 5: Echtzeitbenachrichtigung
{
  "name": "Experten benachrichtigen",
  "type": "n8n-nodes-base.slack",
  "operation": "post",
  "channel": "@{{ $json.expert_id }}",
  "text": "🔔 Ausnahmefall zugewiesen",
  "blocks": [
    {
      "type": "header",
      "text": { "type": "plain_text", "text": "⚠️ Ausnahmefall erfordert Aufmerksamkeit" }
    },
    {
      "type": "section",
      "fields": [
        { "type": "mrkdwn", "text": "*Fall-ID:*\n{{ $json.case_id }}" },
        { "type": "mrkdwn", "text": "*Risikostufe:*\n{{ $json.risk_level }}" },
        { "type": "mrkdwn", "text": "*Konfidenz:*\n{{ $json.confidence_score }}" },
        { "type": "mrkdwn", "text": "*Wartezeit:*\n{{ $json.queue_time }}" }
      ]
    }
  ]
}

// Workflow: Interaktive KI-Verfeinerung mit Echtzeit-Kollaboration

// Node 1: WebSocket-Verbindung für Echtzeitkommunikation
{
  "name": "WebSocket-Handler",
  "type": "n8n-nodes-base.webhook",
  "webhookUri": "/ws/interactive-ai",
  "responseMode": "responseNode"
}

// Node 2: Sitzungsverwaltung
{
  "name": "Sitzung initialisieren",
  "type": "n8n-nodes-base.redis",
  "operation": "set",
  "key": "session:{{ $json.session_id }}",
  "value": {
    "status": "aktiv",
    "iteration": 0,
    "context": [],
    "created_at": "{{ $now }}"
  },
  "expire": 3600  // 1 Stunde TTL
}

// Node 3: KI-Generierung mit Kontext
{
  "name": "Mit Kontext generieren",
  "type": "@n8n/n8n-nodes-langchain.agent",
  "prompt": `
    Vorherige Iterationen: {{ $json.history }}
    Aktuelles Feedback: {{ $json.feedback }}
    Aufgabe: {{ $json.task }}
    
    Generieren Sie eine verbesserte Version unter Einbeziehung des Feedbacks.
  `,
  "options": {
    "systemMessage": "Du bist ein KI-Assistent, der aus Feedback lernt..."
  }
}

// Node 4: Iteration speichern
{
  "name": "Iteration speichern",
  "type": "n8n-nodes-base.redis",
  "operation": "set",
  "key": "session:{{ $json.session_id }}:iteration:{{ $json.iteration }}",
  "value": {
    "output": "{{ $json.ai_output }}",
    "feedback": "{{ $json.feedback }}",
    "timestamp": "{{ $now }}"
  }
}

// Node 5: An Benutzeroberfläche senden
{
  "name": "An UI pushen",
  "type": "n8n-nodes-base.webhook",
  "webhookUri": "/ui/update",
  "body": {
    "session_id": "{{ $json.session_id }}",
    "iteration": "{{ $json.iteration }}",
    "content": "{{ $json.ai_output }}",
    "suggestions": "{{ $json.alternatives }}",
    "changes_summary": "{{ $json.diff_from_previous }}"
  }
}

// Node 6: Auf Benutzerfeedback warten
{
  "name": "Feedback sammeln",
  "type": "n8n-nodes-base.wait",
  "waitType": "webhook",
  "webhookSuffix": "user-feedback",
  "continue": "receiveWebhook"
}

// Node 7: Auf Abschluss prüfen
{
  "name": "Abschlussprüfung",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "string": [
      { "value1": "={{ $json.action }}", "value2": "approve" }
    ]
  }
}

// Genehmigter Zweig: Finalisieren
{
  "name": "Ausgabe finalisieren",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    // Alle Iterationen in endgültiges Dokument kompilieren
    const iterations = $json.history;
    const finalVersion = $json.current_version;
    
    return [{
      json: {
        final_output: finalVersion,
        revision_history: iterations,
        total_iterations: iterations.length,
        time_to_complete: Date.now() - new Date($json.session_created).getTime(),
        approved_by: $json.user_id,
        approved_at: new Date().toISOString()
      }
    }];
  `
}

// Feedback-Zweig: Schleife fortsetzen
{
  "name": "Iteration inkrementieren",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    return [{
      json: {
        ...$json,
        iteration: ($json.iteration || 0) + 1,
        feedback: $json.user_feedback
      }
    }];
  `
}
// Zurück zu Node 3 (Mit Kontext generieren)

// Workflow: Feedback-Erfassung und Modellverbesserungs-Pipeline

// Node 1: Korrektur erfassen
{
  "name": "Korrekturereignis",
  "type": "n8n-nodes-base.webhook",
  "webhookUri": "/feedback/correction"
}

// Node 2: In Feedback-Datenbank speichern
{
  "name": "Korrektur protokollieren",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "ai_feedback",
  "columns": {
    "original_prediction": "={{ $json.ai_output }}",
    "human_correction": "={{ $json.corrected_output }}",
    "correction_type": "={{ $json.correction_category }}",
    "model_version": "={{ $json.model_version }}",
    "confidence_at_prediction": "={{ $json.confidence }}",
    "context": "={{ JSON.stringify($json.context) }}",
    "created_at": "={{ $now }}"
  }
}

// Node 3: Modelldrift berechnen
{
  "name": "Fehlermuster analysieren",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    WITH recent_errors AS (
      SELECT correction_type, COUNT(*) as count
      FROM ai_feedback
      WHERE created_at > NOW() - INTERVAL '7 days'
      GROUP BY correction_type
    ),
    baseline AS (
      SELECT correction_type, COUNT(*) as count
      FROM ai_feedback
      WHERE created_at > NOW() - INTERVAL '30 days'
        AND created_at <= NOW() - INTERVAL '7 days'
      GROUP BY correction_type
    )
    SELECT 
      r.correction_type,
      r.count as recent_count,
      b.count as baseline_count,
      ((r.count - b.count)::float / NULLIF(b.count, 0)) as drift_percentage
    FROM recent_errors r
    LEFT JOIN baseline b ON r.correction_type = b.correction_type
    WHERE ((r.count - b.count)::float / NULLIF(b.count, 0)) > 0.2
  `
}

// Node 4: Neu-Training auslösen, falls erforderlich
{
  "name": "Neu-Trainingsschwelle prüfen",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "number": [
      { "value1": "={{ $json.length }}", "operation": "gt", "value2": 5 }
    ]
  }
}

// Neu-Training-Zweig
{
  "name": "Modell-Neu-Training auslösen",
  "type": "n8n-nodes-base.httpRequest",
  "method": "POST",
  "url": "https://ml-ops.example.com/retrain",
  "body": {
    "model_id": "{{ $json.model_id }}",
    "new_training_data_query": "SELECT * FROM ai_feedback WHERE created_at > NOW() - INTERVAL '30 days'",
    "priority": "high"
  }
}

// Node 5: Trainingsdatensatz aktualisieren
{
  "name": "An Trainings-Pipeline exportieren",
  "type": "n8n-nodes-base.s3",
  "operation": "upload",
  "bucket": "ai-training-data",
  "key": "corrections/{{ $now.format('YYYY/MM/DD') }}/{{ $json.id }}.json",
  "data": "={{ JSON.stringify($json) }}"
}

// Node 6: ML-Team benachrichtigen
{
  "name": "Bei Drift alarmieren",
  "type": "n8n-nodes-base.slack",
  "condition": "={{ $json.drift_percentage > 0.3 }}",
  "operation": "post",
  "channel": "#ml-alerts",
  "text": "⚠️ Modelldrift erkannt: {{ $json.correction_type }} Fehler um {{ $json.drift_percentage }}% gestiegen"
}

// Node: Genehmigeridentität validieren
{
  "name": "Genehmiger verifizieren",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const approver = $json.approver_email;
    const requiredApprovalLevel = $json.approval_level;
    
    // Gegen Verzeichnisdienst prüfen
    const userProfile = await fetchUserFromDirectory(approver);
    
    // Genehmigungsberechtigung validieren
    if (!userProfile.approval_levels.includes(requiredApprovalLevel)) {
      throw new Error(
        \`Benutzer \${approver} ist nicht für \${requiredApprovalLevel}-Genehmigungen berechtigt\`
      );
    }
    
    // Delegation prüfen
    if (userProfile.is_delegated) {
      $json.actual_approver = userProfile.delegated_to;
      $json.delegation_chain = [approver, userProfile.delegated_to];
    }
    
    return [$json];
  `
}

// Node: KI-Ergebnisse für ähnliche Anfragen zwischenspeichern
{
  "name": "Cache prüfen",
  "type": "n8n-nodes-base.redis",
  "operation": "get",
  "key": "ai-cache:{{ $json.request_hash }}"
}

// Node: Cache-Treffer-Antwort
{
  "name": "Zwischengespeichert zurückgeben",
  "type": "n8n-nodes-base.respondToWebhook",
  "respondWith": "json",
  "responseBody": {
    "result": "={{ $json.cached_result }}",
    "source": "cache",
    "cached_at": "={{ $json.cached_at }}"
  }
}

// Node: Ähnliche Genehmigungen stapeln
{
  "name": "Stapel sammeln",
  "type": "n8n-nodes-base.aggregate",
  "aggregate": "individualFields",
  "destinationFieldName": "batch",
  "fieldsToAggregate": {
    "include": ["request_id", "content", "approval_type"]
  },
  "options": {
    "batchSize": 10,
    "batchTimeout": 300  // Sekunden
  }
}

// Umfassende Audit-Protokollierung
{
  "name": "Workflow-Audit-Log",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "hitl_audit_log",
  "columns": {
    "workflow_id": "={{ $execution.id }}",
    "workflow_name": "={{ $workflow.name }}",
    "trigger_type": "={{ $execution.mode }}",
    "start_time": "={{ $execution.startTime }}",
    "ai_decision": "={{ JSON.stringify($json.ai_recommendation) }}",
    "human_decision": "={{ $json.human_decision }}",
    "decision_maker": "={{ $json.approver_id }}",
    "decision_time": "={{ $now }}",
    "justification": "={{ $json.decision_reason }}",
    "ip_address": "={{ $json.client_ip }}",
    "user_agent": "={{ $json.user_agent }}",
    "compliance_tags": "={{ $json.compliance_requirements }}"
  }
}

// Policy-Engine-Implementierung
{
  "name": "Geschäftsrichtlinien durchsetzen",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const policies = {
      spending_limits: {
        manager: 5000,
        director: 50000,
        vp: 250000
      },
      restricted_vendors: ['vendor-a', 'vendor-b'],
      required_approvers: {
        it_changes: ['security', 'architecture'],
        hr_decisions: ['hr_business_partner', 'legal']
      }
    };
    
    const violations = [];
    
    // Ausgabenberechtigung prüfen
    if ($json.amount > policies.spending_limits[$json.approver_role]) {
      violations.push('Betrag übersteigt Genehmigungsberechtigung');
    }
    
    // Eingeschränkte Anbieter prüfen
    if (policies.restricted_vendors.includes($json.vendor_id)) {
      violations.push('Anbieter steht auf eingeschränkter Liste');
    }
    
    if (violations.length > 0) {
      throw new Error(\`Richtlinienverstöße: \${violations.join(', ')}\`);
    }
    
    return [$json];
  `
}